@useinsider/guido 3.7.2-beta.1489585 → 3.7.2-beta.2220fb0

package/dist/src/extensions/Blocks/Recommendation/controls/index.d.ts

@@ -9,7 +9,7 @@
  * // Or individual imports
  * import { NameAlignControl, ButtonColorControl } from './controls';
  */
-export { RecommendationBlockControl, CONTROL_BLOCK_ID, AlgorithmControl, ALGORITHM_CONTROL_ID, LocaleControl, LOCALE_CONTROL_ID, CurrencyControl, CURRENCY_CONTROL_ID, ProductCountControl, PRODUCT_COUNT_CONTROL_ID, ProductLayoutControl, PRODUCT_LAYOUT_CONTROL_ID, FiltersControl, FILTERS_CONTROL_ID, ShuffleControl, SHUFFLE_CONTROL_ID, LayoutOrientationControl, LAYOUT_ORIENTATION_CONTROL_ID, } from './main';
+export { RecommendationBlockControl, CONTROL_BLOCK_ID, AlgorithmControl, ALGORITHM_CONTROL_ID, LocaleControl, LOCALE_CONTROL_ID, CurrencyControl, CURRENCY_CONTROL_ID, ProductCountControl, PRODUCT_COUNT_CONTROL_ID, ProductLayoutControl, PRODUCT_LAYOUT_CONTROL_ID, FiltersControl, FILTERS_CONTROL_ID, ShuffleControl, SHUFFLE_CONTROL_ID, LayoutOrientationControl, LAYOUT_ORIENTATION_CONTROL_ID, PricePlacementControl, PRICE_PLACEMENT_CONTROL_ID, } from './main';
 export * from './main/utils';
 export { NameControls } from './name';
 export { PriceControls } from './price';

package/dist/src/extensions/Blocks/Recommendation/controls/main/index.d.ts

@@ -5,11 +5,12 @@ import { CurrencyControl, CURRENCY_CONTROL_ID } from './currency';
 import { FiltersControl, FILTERS_CONTROL_ID } from './filters';
 import { LayoutOrientationControl, LAYOUT_ORIENTATION_CONTROL_ID } from './layoutOrientation';
 import { LocaleControl, LOCALE_CONTROL_ID } from './locale';
+import { PricePlacementControl, PRICE_PLACEMENT_CONTROL_ID } from './pricePlacement';
 import { ProductCountControl, PRODUCT_COUNT_CONTROL_ID } from './productCount';
 import { ProductLayoutControl, PRODUCT_LAYOUT_CONTROL_ID } from './productLayout';
 import { ShuffleControl, SHUFFLE_CONTROL_ID } from './shuffle';
 export declare const CONTROL_BLOCK_ID = "ui-elements-recommendation-block";
-export { AlgorithmControl, ALGORITHM_CONTROL_ID, LocaleControl, LOCALE_CONTROL_ID, CurrencyControl, CURRENCY_CONTROL_ID, ProductCountControl, PRODUCT_COUNT_CONTROL_ID, ProductLayoutControl, PRODUCT_LAYOUT_CONTROL_ID, FiltersControl, FILTERS_CONTROL_ID, ShuffleControl, SHUFFLE_CONTROL_ID, LayoutOrientationControl, LAYOUT_ORIENTATION_CONTROL_ID, };
+export { AlgorithmControl, ALGORITHM_CONTROL_ID, LocaleControl, LOCALE_CONTROL_ID, CurrencyControl, CURRENCY_CONTROL_ID, ProductCountControl, PRODUCT_COUNT_CONTROL_ID, ProductLayoutControl, PRODUCT_LAYOUT_CONTROL_ID, FiltersControl, FILTERS_CONTROL_ID, ShuffleControl, SHUFFLE_CONTROL_ID, LayoutOrientationControl, LAYOUT_ORIENTATION_CONTROL_ID, PricePlacementControl, PRICE_PLACEMENT_CONTROL_ID, };
 export * from './utils';
 /**
  * Main recommendation block control that composes all sub-controls
@@ -26,6 +27,7 @@ export declare class RecommendationBlockControl extends CommonControl {
     private productLayoutControl;
     private filtersControl;
     private shuffleControl;
+    private pricePlacementControl;
     private layoutOrientationControl;
     getId(): string;
     getTemplate(): string;

package/dist/src/extensions/Blocks/Recommendation/controls/main/layoutOrientation.d.ts

@@ -31,8 +31,7 @@ export declare class LayoutOrientationControl extends CommonControl {
      * 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)
-     * @param composition - The preserved card composition, incl. customAttr:* entries
      */
-    _regenerateProductRows(layout: Orientation, composition: string[]): void;
+    _regenerateProductRows(layout: Orientation): void;
     _listenToFormUpdates(): void;
 }

package/dist/src/extensions/Blocks/Recommendation/controls/main/pricePlacement.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Price Placement Control
+ *
+ * Two block-level price settings ported from the legacy product block, shown
+ * above the Currency control in the main Settings tab:
+ *
+ * - "Product Price Orientation" (`priceMovedToNextLine`): a vertical/horizontal
+ *   icon radio (mirrors the Items block control). `vertical` (default) keeps the
+ *   price and original price on separate stacked rows (current Guido look);
+ *   `horizontal` renders them inline on the same line and Card Composition
+ *   collapses them into a single "Product Prices" entry.
+ * - "Hide if same as discounted" (`priceHideIfSameAsDiscounted`): a toggle.
+ *   When ON, email-service blanks the redundant original price at send time when
+ *   it equals the sale price (see the `hide-price` block attribute below).
+ *
+ * Orientation re-renders the rows (it changes the saved template layout).
+ * Hide-if-same NEVER touches the template — it only persists config + stamps the
+ * `hide-price` attribute; the visual hide is simulated in the preview and applied
+ * for real server-side by email-service.
+ */
+import type { RecommendationNodeConfig } from '../../types/nodeConfig';
+import type { ImmutableHtmlNode } from '@stripoinc/ui-editor-extensions';
+import { CommonControl } from '../../../common-control';
+export declare const PRICE_PLACEMENT_CONTROL_ID = "recommendation-price-placement-control";
+type Orientation = 'vertical' | 'horizontal';
+/**
+ * Control for the block-level price orientation radio + hide-if-same toggle.
+ */
+export declare class PricePlacementControl extends CommonControl {
+    private store;
+    getId(): string;
+    getTemplate(): string;
+    onRender(): void;
+    onTemplateNodeUpdated(node: ImmutableHtmlNode): void;
+    _setFormValues(config: RecommendationNodeConfig): void;
+    _initializeHideToggle(config: RecommendationNodeConfig): void;
+    /**
+     * Disables the orientation radio when a price element is hidden via Card
+     * Composition — orientation is meaningless without both prices visible.
+     * Visibility lives on the attribute rows' `data-visibility` (set by the Card
+     * Composition control). Inline mode has no standalone original-price row, so
+     * the merged "Product Prices" entry (the price row) governs.
+     */
+    _updateOrientationDisabled(): void;
+    _onOrientationChange(orientation: Orientation): void;
+    _onHideIfSameChange(value: boolean): void;
+    /**
+     * Mirrors the hide-if-same flag onto the durable `hide-price` block attribute
+     * read by email-service at send time.
+     */
+    _stampHideIfSameAttr(value: boolean): void;
+    /**
+     * Rebuilds the product rows so the renderer re-reads the inline/stacked
+     * layout flag from the store. Used by the orientation change only.
+     */
+    _regenerate(): void;
+    _listenToFormUpdates(): void;
+}
+export {};

package/dist/src/extensions/Blocks/Recommendation/controls/main/utils.d.ts

@@ -60,17 +60,39 @@ export interface RegenerateProductRowsOptions {
     composition?: string[];
 }
 /**
- * Regenerates only the mobile product container rows and commits in a single apply().
- * Standalone entry point for callers that change mobile-only settings
- * (block.ts, productLayout.ts). The combined desktop+mobile regeneration uses the
- * apply-free accumulateMobileProductRows() so the whole rebuild is one commit.
+ * Regenerates only the mobile product container rows.
+ * Used when mobile-specific settings change (mobileCardsInRow)
+ * or when the desktop container is regenerated (to keep both in sync).
  *
- * For list layout / disabled mobile layout: clears the mobile row content.
- * For grid layout with mobileLayoutEnabled ON: rebuilds the full mobile row.
+ * For list layout: clears the mobile row content (list rows are inherently responsive).
+ * For grid layout with mobileLayoutEnabled OFF: clears the mobile row content.
+ * For grid layout with mobileLayoutEnabled ON: rebuilds the full mobile row
+ *   structure (<td><table>...products...</table></td>) in a single operation.
  */
 export declare function regenerateMobileProductRows(options: Omit<RegenerateProductRowsOptions, 'afterRegenerate'>): void;
+/**
+ * Regenerates product rows in the desktop container based on current store configuration.
+ * Also regenerates the mobile container to keep both in sync.
+ * Reads products, layout, and composition from store/DOM and rebuilds the HTML.
+ * @param options - Configuration options for regeneration
+ */
+export declare function regenerateProductRows(options: RegenerateProductRowsOptions): void;
+export interface ReapplySpacingOptions {
+    currentNode: ImmutableHtmlNode | null | undefined;
+    documentModifier: DocumentModifier;
+}
+/**
+ * Reapplies spacing values after product regeneration.
+ * Desktop spacing applies only to the desktop container;
+ * mobile spacing applies only to the mobile container.
+ *
+ * Reads values from node config (primary) with data-attribute fallback
+ * for backward compatibility with pre-nodeConfig templates.
+ * @param options - Configuration options
+ */
+export declare function reapplySpacing(options: ReapplySpacingOptions): void;
 export interface RegenerateWithStylesOptions extends Omit<RegenerateProductRowsOptions, 'products' | 'layout'> {
-    /** Skip style capture if styles were already handled externally */
+    /** Skip style capture/restore if styles were already handled externally */
     skipStylePreservation?: boolean;
     /** Optional: pass products directly instead of reading from store */
     products?: RecommendationProduct[];
@@ -78,21 +100,26 @@ export interface RegenerateWithStylesOptions extends Omit<RegenerateProductRowsO
     layout?: Orientation;
 }
 /**
- * Regenerates product rows while preserving user-applied styles, in a SINGLE commit.
+ * Regenerates product rows while preserving user-applied styles
+ *
+ * This unified function handles the complete regeneration flow:
+ * 1. Captures existing styles (fonts, colors, button styles, etc.)
+ * 2. Regenerates HTML with new products/layout
+ * 3. Restores captured styles to new elements
+ * 4. Reapplies spacing from data attributes
  *
- * Flow:
- * 1. Capture the current per-attribute style templates (tag wrappers + p-style) and
- *    spacing — read from the live DOM BEFORE it is replaced.
- * 2. Accumulate the desktop + mobile rebuilds, with spacing and the captured styles
- *    baked straight into the generated HTML.
- * 3. Commit everything with ONE apply().
+ * NOTE: Style restoration is temporarily disabled due to Stripo selection bug.
+ * Multiple apply() calls (setInnerHtml + restoreStyles + reapplySpacing) cause
+ * Stripo's internal cursor/selection tracking to lose node references, resulting in
+ * "Cannot read properties of undefined (reading 'textContent')" errors.
  *
- * Why one apply(): each apply() is a Stripo commit boundary that re-resolves the
- * editor's selection against node references. A setInnerHtml rebuild destroys the old
- * text nodes, so a second (or deferred) commit left the inline-format tracker pointing
- * at gone nodes — the "Cannot read properties of undefined (reading 'textContent')"
- * crash when toggling bold/italic/strike afterwards. Baking spacing + styles into the
- * HTML removes the need for any post-rebuild reapply pass.
+ * Use this instead of `regenerateProductRows` when styles must be preserved.
+ * @example
+ * // When products change (API response, count change, layout change)
+ * regenerateProductRowsWithStyles({
+ *     currentNode: this.currentNode,
+ *     documentModifier: this.api.getDocumentModifier(),
+ * });
  * @param options - Configuration options for regeneration
  */
 export declare function regenerateProductRowsWithStyles(options: RegenerateWithStylesOptions): void;

package/dist/src/extensions/Blocks/Recommendation/store/recommendation.d.ts

@@ -25,6 +25,8 @@ export interface PerBlockConfigs {
     unresponsive: boolean;
     size: string;
     customAttributes: string[];
+    priceMovedToNextLine: boolean;
+    priceHideIfSameAsDiscounted: boolean;
 }
 interface PerBlockState {
     recommendationConfigs: PerBlockConfigs;

package/dist/src/extensions/Blocks/Recommendation/templates/grid/elementRenderer.d.ts

@@ -1,3 +1,4 @@
+import type { RecommendationProduct } from '@@/Types/recommendation';
 import { type ElementRenderer } from '../utils';
 /**
  * Grid element renderer
@@ -24,4 +25,19 @@ export declare const ATTRIBUTE_CELL_CLASS = "attribute-cell";
  * card-composition control so both render identical filler markup.
  */
 export declare function buildFillerCell(columnWidth: string, padding?: string): string;
+/**
+ * Renders the inline price cell used when "Move to next line" is OFF: the sale
+ * price and original price sit side by side in a single attribute cell, each
+ * keeping its own `esd-extension-block-id` + `product-*` class so the per-element
+ * style controls and the compiler keep working.
+ *
+ * `originalFirst` preserves the card-composition order (original before sale when
+ * `productOldPrice` precedes `productPrice` in the composition) so the side-by-side
+ * order matches the stacked order.
+ */
+export declare function renderInlineGridPriceCell(product: RecommendationProduct, originalFirst?: boolean): string;
+/**
+ * Standalone (stacked) original-price cell.
+ */
+export declare function renderGridOldPriceCell(product: RecommendationProduct): string;
 export declare const gridElementRenderer: ElementRenderer;

package/dist/src/extensions/Blocks/Recommendation/templates/grid/template.d.ts

@@ -1,5 +1,5 @@
 import type { FiltersResponse, RecommendationProduct } from '@@/Types/recommendation';
-import { type ElementRenderer, type RenderOptions } from '../utils';
+import { type ElementRenderer, type PricePlacementFlags } from '../utils';
 /**
  * Generates attribute-aligned product rows for grid layout.
  * Creates rows where each row contains one attribute type from all products.
@@ -9,7 +9,7 @@ import { type ElementRenderer, type RenderOptions } from '../utils';
  * @param composition - Array defining order of card elements
  * @returns HTML string for attribute-aligned rows
  */
-export declare function prepareGridAttributeRows(products: RecommendationProduct[], productsPerRow: number, elementRenderer: ElementRenderer, composition?: string[], filterList?: FiltersResponse, renderOptions?: RenderOptions): string;
+export declare function prepareGridAttributeRows(products: RecommendationProduct[], productsPerRow: number, elementRenderer: ElementRenderer, composition?: string[], filterList?: FiltersResponse, flags?: PricePlacementFlags): string;
 /**
  * Prepares grid product rows with attribute-aligned structure
  * Groups products into rows, then generates attribute-aligned HTML for each group
@@ -19,7 +19,7 @@ export declare function prepareGridAttributeRows(products: RecommendationProduct
  * @param composition - Array defining order of card elements
  * @returns HTML string for all product rows
  */
-export declare function prepareGridProductRows(products: RecommendationProduct[], productsPerRow: number, elementRenderer: ElementRenderer, composition?: string[], filterList?: FiltersResponse, renderOptions?: RenderOptions): string;
+export declare function prepareGridProductRows(products: RecommendationProduct[], productsPerRow: number, elementRenderer: ElementRenderer, composition?: string[], filterList?: FiltersResponse, flags?: PricePlacementFlags): string;
 /**
  * Prepares grid product rows with attribute-aligned structure.
  * Uses row-based rendering where each attribute type forms a single row across all products.
@@ -28,6 +28,6 @@ export declare function prepareGridProductRows(products: RecommendationProduct[]
  * @param composition - Array defining element order
  * @returns HTML string for product rows
  */
-export declare function prepareProductRows(products: RecommendationProduct[], productsPerRow: number, composition?: string[], filterList?: FiltersResponse, renderOptions?: RenderOptions): string;
+export declare function prepareProductRows(products: RecommendationProduct[], productsPerRow: number, composition?: string[], filterList?: FiltersResponse, flags?: PricePlacementFlags): string;
 export declare function getDefaultTemplate(recommendationId?: number): string;
 export declare function generateBlockTemplate(products: RecommendationProduct[], productsPerRow: number, title?: string, composition?: string[], mobileProductsPerRow?: number): string;

package/dist/src/extensions/Blocks/Recommendation/templates/index.d.ts

@@ -6,7 +6,7 @@
  */
 import type { RecommendationProduct } from '@@/Types/recommendation';
 import { type Orientation, type PrepareProductRowsOptions } from './utils';
-export { DEFAULTS, DEFAULT_CARD_COMPOSITION, DEFAULT_CARD_VISIBILITY, getDefaultProducts, spacer, sanitizeImageUrl, createBlockTemplate, toDisplayableAttributeValue, type Orientation, type PrepareProductRowsOptions, type ElementRenderer, type ProductCardGetter, type AttributeStyleTemplate, type AttributeStyleTemplates, type CellBackgroundColors, type CellAlignments, type CellClasses, type OmnibusTexts, } from './utils';
+export { DEFAULTS, DEFAULT_CARD_COMPOSITION, DEFAULT_CARD_VISIBILITY, getDefaultProducts, isSamePrice, spacer, sanitizeImageUrl, createBlockTemplate, toDisplayableAttributeValue, type Orientation, type PrepareProductRowsOptions, type ElementRenderer, type ProductCardGetter, } from './utils';
 /**
  * Unified function to prepare product rows for any layout.
  * Delegates to the appropriate layout-specific implementation.

package/dist/src/extensions/Blocks/Recommendation/templates/list/elementRenderer.d.ts

@@ -1,3 +1,4 @@
+import type { RecommendationProduct } from '@@/Types/recommendation';
 import { type ElementRenderer } from '../utils';
 /**
  * List element renderer
@@ -5,4 +6,16 @@ import { type ElementRenderer } from '../utils';
  * - Name and Prices return `<tr><td>` rows for the info cell table
  * All elements have esd-block-* classes for Stripo selection
  */
+/**
+ * Standalone (stacked) original-price info row.
+ */
+export declare function renderListOldPriceRow(product: RecommendationProduct): string;
+/**
+ * Inline price info row used when "Move to next line" is OFF: the sale price and
+ * original price sit in two cells of one row. Each keeps its block id + class so
+ * style controls and the compiler keep working. `originalFirst` preserves the
+ * card-composition order (original before sale by default) so it matches the
+ * stacked order.
+ */
+export declare function renderInlineListPriceRow(product: RecommendationProduct, originalFirst?: boolean): string;
 export declare const listElementRenderer: ElementRenderer;

package/dist/src/extensions/Blocks/Recommendation/templates/list/template.d.ts

@@ -1,5 +1,5 @@
 import type { FiltersResponse, RecommendationProduct } from '@@/Types/recommendation';
-import { type RenderOptions } from '../utils';
+import { type PricePlacementFlags } from '../utils';
 /**
  * Generates a list product card with 3-column layout
  * Uses buildElementRenderer to render Image, Info content, and Button
@@ -12,7 +12,7 @@ import { type RenderOptions } from '../utils';
  * @param composition - Array defining order of card elements
  * @returns HTML string for a single product card row
  */
-export declare function getListProductCard(product: RecommendationProduct, composition?: string[], filterList?: FiltersResponse, renderOptions?: RenderOptions): string;
+export declare function getListProductCard(product: RecommendationProduct, composition?: string[], filterList?: FiltersResponse, flags?: PricePlacementFlags): string;
 /**
  * Prepares list product rows
  * Each product is a full-width row with 3-column layout
@@ -20,6 +20,6 @@ export declare function getListProductCard(product: RecommendationProduct, compo
  * @param composition - Array defining order of card elements
  * @returns HTML string for product rows
  */
-export declare function prepareProductRows(products: RecommendationProduct[], composition?: string[], filterList?: FiltersResponse, renderOptions?: RenderOptions): string;
+export declare function prepareProductRows(products: RecommendationProduct[], composition?: string[], filterList?: FiltersResponse, flags?: PricePlacementFlags): string;
 export declare function getDefaultTemplate(): string;
 export declare function generateBlockTemplate(products: RecommendationProduct[], title?: string, composition?: string[]): string;

package/dist/src/extensions/Blocks/Recommendation/templates/utils.d.ts

@@ -1,10 +1,39 @@
+import type { CurrencyConfig } from '../types/nodeConfig';
 import type { FiltersResponse, RecommendationProduct } from '@@/Types/recommendation';
 import { ATTR_PRODUCT_IMAGE, ATTR_PRODUCT_NAME, ATTR_PRODUCT_PRICE, ATTR_PRODUCT_OLD_PRICE, ATTR_PRODUCT_OMNIBUS_PRICE, ATTR_PRODUCT_OMNIBUS_DISCOUNT, ATTR_PRODUCT_BUTTON } from '../constants';
+type PriceKey = 'price' | 'original_price' | 'discount';
+/**
+ * Current currency configuration from the store, in CurrencyConfig shape.
+ */
+export declare function getCurrentCurrencyConfig(): CurrencyConfig;
+/**
+ * Formats a product price using current currency settings. Falls back to the
+ * first available currency, then 0, when the active currency has no value.
+ */
+export declare function formatProductPrice(product: RecommendationProduct, priceKey?: PriceKey): string;
+/**
+ * True when the formatted sale price equals the formatted original price.
+ * Mirrors the email-service / preview hide-if-same comparison semantics
+ * (formatted-string equality, same currency fallback chain).
+ */
+export declare function isSamePrice(product: RecommendationProduct): boolean;
 /**
  * Converts a snake_case attribute name to Title Case display name.
  * e.g., "rating_star" → "Rating Star"
  */
 export declare function toDisplayName(attrName: string): string;
+/**
+ * Resolves the inline (side-by-side) price layout from the composition order so
+ * it matches the stacked order. `anchor` is whichever of price / original price
+ * comes first in the composition (the merged cell renders there); `skip` is the
+ * other (dropped, since it's merged in); `originalFirst` puts the original price
+ * on the left when it precedes the sale price (the default composition order).
+ */
+export declare function resolveInlinePriceOrder(composition: string[]): {
+    originalFirst: boolean;
+    anchor: string;
+    skip: string;
+};
 /**
  * Reduces a raw product-attribute value to a displayable scalar string.
  * Array-type attributes (filter types `Strings`/`Numbers`) are substituted with
@@ -25,20 +54,13 @@ export declare function isDefaultAttribute(attrName: string, filterList: Filters
  * - Product attributes → "product_attribute.<name>" (e.g., "product_attribute.rating_star")
  */
 export declare function resolveProductAttrValue(attrName: string, filterList: FiltersResponse): string;
-/**
- * Reverse of `resolveProductAttrValue`: maps a cell's `product-attr` value back to its
- * `customAttr:<name>` composition key. The resolver only ever emits `<name>` (default
- * attribute) or `product_attribute.<name>` (custom product attribute), so stripping the
- * prefix recovers the attribute name without needing the store's filter list.
- */
-export declare function toCustomCompositionKey(productAttrValue: string): string;
 /**
  * Callback that generates the cell HTML for a custom product attribute.
  * Layout-specific: grid returns `<td>…`, list returns `<tr><td>…</td></tr>`.
  * @param productAttrValue - The resolved `product-attr` value (e.g., "brand" or "product_attribute.rating_star")
  * @param content - The display content for the cell
  */
-export type CustomCellHtmlGetter = (productAttrValue: string, content: string, options?: CellRenderOptions) => string;
+export type CustomCellHtmlGetter = (productAttrValue: string, content: string) => string;
 /**
  * Symbol key for embedding custom attribute HTML in an ElementRenderer.
  * Grid and list renderers store their custom-attribute cell template under this key
@@ -62,98 +84,17 @@ export declare const CUSTOM_CELL_HTML: unique symbol;
 export declare function buildElementRenderer(baseRenderer: ElementRenderer, composition: string[], filterList?: FiltersResponse): ElementRenderer;
 export type Orientation = 'list' | 'grid';
 /**
- * A captured "style template" for one text attribute, used to bake user-applied
- * styling back into regenerated HTML in a SINGLE setInnerHtml/apply pass.
- *
- * Stripo applies inline formats as TAGS (`<strong>`, `<em>`, `<s>`), not CSS, so we
- * preserve the actual wrapper tags around the text — re-emitting `text-decoration`
- * CSS would render a strike that Stripo's own toggle can't detect. `pStyle` carries
- * the `<p>`-level inline CSS (font-size/color/align/etc.).
- */
-export interface AttributeStyleTemplate {
-    /** Raw inline style for the `<p>`, e.g. "font-size: 18px; color: #111;" */
-    pStyle?: string;
-    /** Opening inline-format tags captured around the text (or button label), e.g. "<strong><em>" */
-    openTags?: string;
-    /** Matching closing tags in reverse order, e.g. "</em></strong>" */
-    closeTags?: string;
-    /** Button: inline style of the `<span class="es-button-border">` (background/border/radius). */
-    buttonBorderStyle?: string;
-    /** Button: inline style of the `<a class="es-button">` (color/background/font/padding/width). */
-    buttonAnchorStyle?: string;
-    /** Button: whether "Fit to Container" is on (the `es-fw` class on the border span). */
-    buttonFitToContainer?: boolean;
-    /** Button: the user-edited label text (without wrapper tags), e.g. "Shop Now" instead of "Buy". */
-    buttonText?: string;
-    /** Image: inline style of the `<img>` (width/height/max-width/border-radius/margin). */
-    imgStyle?: string;
-}
-/** Per-attribute style templates keyed by ATTR_PRODUCT_* composition key. */
-export type AttributeStyleTemplates = Record<string, AttributeStyleTemplate>;
-/** Per-attribute "Block Background Color" values keyed by ATTR_PRODUCT_* composition key. */
-export type CellBackgroundColors = Record<string, string>;
-/** Per-attribute text alignment (the cell's `align` attribute) keyed by ATTR_PRODUCT_* composition key. */
-export type CellAlignments = Record<string, string>;
-/** Per-attribute preserved cell classes (padding `es-p*`, margin `es-m*`, text-trim) keyed by attr. */
-export type CellClasses = Record<string, string>;
-/** A user-edited omnibus prefix/suffix, e.g. before = "Lowest 30-day price: ". */
-export interface OmnibusText {
-    before?: string;
-    after?: string;
-}
-/** Per-attribute omnibus before/after texts keyed by ATTR_PRODUCT_OMNIBUS_* composition key. */
-export type OmnibusTexts = Record<string, OmnibusText>;
-/** Per-attribute visibility (show/hide) keyed by ATTR_PRODUCT_* composition key. */
-export type AttributeVisibility = Record<string, boolean>;
-/**
- * Per-cell rendering context passed to each ElementRenderer function so a single
- * regeneration can bake column spacing and preserved styles directly into the HTML.
+ * Options for prepareProductRows unified function
  */
-export interface CellRenderOptions {
-    /** Column-spacing padding for the attribute cell, e.g. "0 7px". Falls back to DEFAULT_CELL_PADDING. */
-    cellPadding?: string;
-    /** Captured style template for this attribute (preserves user bold/italic/strike + p-style). */
-    styleTemplate?: AttributeStyleTemplate;
-    /** Card background color baked onto the `.product-card-segment` of every cell. */
-    cardBackgroundColor?: string;
-    /** This text attribute's "Block Background Color", baked onto its `[esd-extension-block-id]` cell. */
-    cellBackgroundColor?: string;
-    /** This text attribute's alignment, baked onto its `[esd-extension-block-id]` cell `align` attribute. */
-    cellAlignment?: string;
-    /** This cell's preserved spacing/text-trim classes, replacing the renderer's hardcoded `es-p*` defaults. */
-    cellClasses?: string;
-    /** Omnibus cell's user-edited before/after text, replacing the renderer's hardcoded prefix. */
-    omnibusText?: OmnibusText;
-}
 /**
- * Spacing + preserved-style values baked into generated HTML so a regeneration
- * needs only a single setInnerHtml/apply (no deferred reapply pass). Shared by the
- * grid and list layout generators and by `PrepareProductRowsOptions`.
+ * Block-level price placement flags threaded into the row builders.
+ * - `priceInline`: render sale + original price on one line (skip the standalone
+ *   original-price row).
  */
-export interface RenderOptions {
-    /** Column-spacing padding baked into product cells (grid) or the card wrapper (list), e.g. "0 7px". */
-    cellPadding?: string;
-    /** Row-spacing height in px baked into spacer rows between product rows. */
-    rowSpacingPx?: number;
-    /** Per-attribute captured style templates to preserve user styling across regeneration. */
-    styleTemplates?: AttributeStyleTemplates;
-    /** Card background color baked into the card containers (`.product-card-segment` / `.product-card-wrapper`). */
-    cardBackgroundColor?: string;
-    /** Per-attribute "Block Background Color" values baked onto each text cell across regeneration. */
-    cellBackgroundColors?: CellBackgroundColors;
-    /** Per-attribute text alignment baked onto each text cell's `align` attribute across regeneration. */
-    cellAlignments?: CellAlignments;
-    /** Per-attribute preserved cell classes (padding/margin/text-trim) re-baked across regeneration. */
-    cellClasses?: CellClasses;
-    /** Per-attribute omnibus before/after texts re-baked across regeneration. */
-    omnibusTexts?: OmnibusTexts;
-    /** Per-attribute visibility (show/hide) re-applied across regeneration; falls back to defaults. */
-    visibility?: AttributeVisibility;
+export interface PricePlacementFlags {
+    priceInline?: boolean;
 }
-/**
- * Options for prepareProductRows unified function
- */
-export interface PrepareProductRowsOptions extends RenderOptions {
+export interface PrepareProductRowsOptions extends PricePlacementFlags {
     /** Number of products per row (only for grid layout, defaults to 3) */
     productsPerRow?: number;
     /** Number of products per row on mobile (only for grid layout, defaults to 1) */
@@ -171,15 +112,15 @@ export interface PrepareProductRowsOptions extends RenderOptions {
  * for custom attributes — used by `buildElementRenderer` to create custom entries.
  */
 export interface ElementRenderer {
-    [ATTR_PRODUCT_IMAGE]: (product: RecommendationProduct, options?: CellRenderOptions) => string;
-    [ATTR_PRODUCT_NAME]: (product: RecommendationProduct, options?: CellRenderOptions) => string;
-    [ATTR_PRODUCT_PRICE]: (product: RecommendationProduct, options?: CellRenderOptions) => string;
-    [ATTR_PRODUCT_OLD_PRICE]: (product: RecommendationProduct, options?: CellRenderOptions) => string;
-    [ATTR_PRODUCT_OMNIBUS_PRICE]: (product: RecommendationProduct, options?: CellRenderOptions) => string;
-    [ATTR_PRODUCT_OMNIBUS_DISCOUNT]: (product: RecommendationProduct, options?: CellRenderOptions) => string;
-    [ATTR_PRODUCT_BUTTON]: (product: RecommendationProduct, options?: CellRenderOptions) => string;
+    [ATTR_PRODUCT_IMAGE]: (product: RecommendationProduct) => string;
+    [ATTR_PRODUCT_NAME]: (product: RecommendationProduct) => string;
+    [ATTR_PRODUCT_PRICE]: (product: RecommendationProduct) => string;
+    [ATTR_PRODUCT_OLD_PRICE]: (product: RecommendationProduct) => string;
+    [ATTR_PRODUCT_OMNIBUS_PRICE]: (product: RecommendationProduct) => string;
+    [ATTR_PRODUCT_OMNIBUS_DISCOUNT]: (product: RecommendationProduct) => string;
+    [ATTR_PRODUCT_BUTTON]: (product: RecommendationProduct) => string;
     [CUSTOM_CELL_HTML]?: CustomCellHtmlGetter;
-    [key: string]: (product: RecommendationProduct, options?: CellRenderOptions) => string;
+    [key: string]: (product: RecommendationProduct) => string;
 }
 /**
  * Product card getter function type
@@ -192,65 +133,7 @@ export declare const DEFAULTS: {
 };
 export declare const DEFAULT_CARD_COMPOSITION: string[];
 export declare const DEFAULT_CARD_VISIBILITY: Record<string, boolean>;
-/** Default row-spacing height in px, used when no explicit value is baked in. */
-export declare const DEFAULT_ROW_SPACING_PX = 10;
-/**
- * Builds a spacer row with the given height. Baking row spacing into the HTML lets
- * regeneration use a single setInnerHtml/apply instead of a deferred reapply pass.
- */
-export declare function buildSpacer(heightPx?: number): string;
-export declare const spacer: string;
-/**
- * Resolves the `<p>` inline style for a text cell. When a captured template exists,
- * it wins (even when empty — meaning the user cleared the style); otherwise the
- * renderer's default style is used.
- */
-export declare function resolvePStyle(defaultPStyle: string, template?: AttributeStyleTemplate): string;
-/**
- * Renders `<p>…text…</p>` for a text attribute, preserving captured inline-format
- * tags (`<strong>`/`<em>`/`<s>`) and p-style when a template is supplied, or falling
- * back to the renderer defaults. A present-but-empty template faithfully drops the
- * default wrapper (e.g. the user removed bold).
- */
-export declare function renderStyledParagraph(text: string, defaults: {
-    pStyle: string;
-    openTags: string;
-    closeTags: string;
-}, template?: AttributeStyleTemplate): string;
-/**
- * Builds the inline style for a card container (`.product-card-segment` in grid,
- * `.product-card-wrapper` in list), appending the captured card background color to any
- * base style. Returns '' when there is nothing to set.
- */
-export declare function resolveSegmentBgStyle(baseStyle: string, cardBackgroundColor?: string): string;
-/**
- * Builds the ` style="background-color: …"` attribute for a text attribute's
- * `[esd-extension-block-id]` cell, baking in the captured "Block Background Color".
- * Returns '' when there is nothing to set (the cell otherwise carries no inline style).
- */
-export declare function cellBgStyleAttr(cellBackgroundColor?: string): string;
-/** Resolves an omnibus cell's before/after text, falling back to the renderer's defaults. */
-export declare function resolveOmnibusText(captured?: OmnibusText, defaultBefore?: string): Required<OmnibusText>;
-/**
- * Wraps a button label in the captured inline-format tags (bold/italic), or returns it
- * plain. Mirrors text wrapper preservation for the button's `<a>` content.
- */
-export declare function renderButtonLabel(label: string, template?: AttributeStyleTemplate): string;
-/**
- * Resolves the `<span class="es-button-border">` class, adding `es-fw` (full-width)
- * when the captured template had "Fit to Container" on. Stripo applies fit via this
- * class, not inline width, so we preserve the class across regeneration.
- */
-export declare function resolveButtonBorderClass(template?: AttributeStyleTemplate): string;
-/** Default inline style for the product image `<img>` (used when nothing is captured). */
-export declare const DEFAULT_IMG_STYLE = "display: block; max-width: 100%; height: auto;";
-/** Default inline style for the button `<span class="es-button-border">`. */
-export declare const DEFAULT_BUTTON_BORDER_STYLE: string;
-/**
- * Default inline style for the button `<a class="es-button">`. The list layout appends its
- * own `padding: 5px 30px;` on top of this shared base.
- */
-export declare const DEFAULT_BUTTON_ANCHOR_STYLE: string;
+export declare const spacer = "\n    <tr>\n        <td class=\"spacer\" style=\"height: 10px;\"></td>\n    </tr>\n";
 export declare const PLACEHOLDER_IMAGE = "https://email-static.useinsider.com/stripo/modules/email-recommendation-v3/assets/images/image-placeholder.png";
 /**
  * Sanitizes product image URLs for consistent rendering
@@ -278,3 +161,4 @@ export declare function getDefaultProducts(count?: number): RecommendationProduc
  * @returns HTML template string with {-{-TITLE-}-}, {-{-PRODUCT_ROWS-}-}, and {-{-MOBILE_PRODUCT_ROWS-}-} (grid only) placeholders
  */
 export declare function createBlockTemplate(layout?: Orientation, instanceClass?: string): string;
+export {};

package/dist/src/extensions/Blocks/Recommendation/types/nodeConfig.d.ts

@@ -152,6 +152,21 @@ export interface RecommendationNodeConfig {
      * Whether to trim long product names with ellipsis
      */
     textTrimming: boolean;
+    /**
+     * Whether the price and original price render on separate stacked lines.
+     * - true (default): each on its own attribute row (current Guido look)
+     * - false: both rendered inline on the same line, and Card Composition
+     *   collapses them into a single "Product Prices" entry
+     * Ported from the legacy product block's `isPriceMovedToNextLine`.
+     */
+    priceMovedToNextLine: boolean;
+    /**
+     * Whether to hide the redundant original price when it equals the sale
+     * price (no real discount). Enforced in the real email via a liquid
+     * condition and mirrored in the editor on mock data.
+     * Ported from the legacy product block's `isPriceDeletedForZeroSale`.
+     */
+    priceHideIfSameAsDiscounted: boolean;
     /**
      * Configuration version for future migrations
      * Increment when making breaking changes to schema

package/dist/src/extensions/Blocks/Recommendation/utils/preserveTextStyles.d.ts

@@ -1,19 +1,4 @@
 import type { ImmutableHtmlNode } from '@stripoinc/ui-editor-extensions';
-/**
- * Extracts the nested inline-format wrapper tags around text content, outermost first.
- *
- * Stripo applies bold/italic/underline/strike as tags (`<strong>/<em>/<u>/<s>`), so to
- * preserve user formatting across a text swap or block regeneration we capture the actual
- * wrapper tags rather than CSS.
- * @example
- * // '<strong><em>Hi</em></strong>' → { openTags: '<strong><em>', closeTags: '</em></strong>' }
- * @param html - The inner HTML to parse
- * @returns The concatenated opening tags and matching closing tags (empty strings if none)
- */
-export declare function extractWrapperTags(html: string): {
-    openTags: string;
-    closeTags: string;
-};
 /**
  * Preserves existing style tags when updating text content
  *