@useinsider/guido 3.6.0-beta.596b70e → 3.6.0-beta.5cbaa8f

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

@@ -23,7 +23,7 @@ export declare function resolveProductAttrValue(attrName: string, filterList: Fi
  * @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
@@ -46,70 +46,10 @@ 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;
-    /** 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-cell rendering context passed to each ElementRenderer function so a single
- * regeneration can bake column spacing and preserved styles directly into the HTML.
- */
-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;
-}
-/**
- * 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`.
- */
-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;
-}
 /**
  * Options for prepareProductRows unified function
  */
-export interface PrepareProductRowsOptions extends RenderOptions {
+export interface PrepareProductRowsOptions {
     /** 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) */
@@ -127,15 +67,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
@@ -148,63 +88,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;
-/**
- * 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

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
  *

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

@@ -0,0 +1,113 @@
+/**
+ * Style Preserver Utility
+ *
+ * Captures and restores element styles during block regeneration.
+ * This ensures user styling is preserved when:
+ * - Layout changes (grid <-> list)
+ * - Cards per row changes
+ * - Composition order changes
+ *
+ * Works with the node config system to provide complete style persistence.
+ */
+import type { ImmutableHtmlNode } from '@stripoinc/ui-editor-extensions';
+import { ModificationDescription } from '@stripoinc/ui-editor-extensions';
+/**
+ * Style properties that can be captured for text elements
+ */
+export interface TextElementStyles {
+    fontSize?: string;
+    fontFamily?: string;
+    fontWeight?: string;
+    fontStyle?: string;
+    color?: string;
+    textAlign?: string;
+    lineHeight?: string;
+    textDecoration?: string;
+}
+/**
+ * Style properties for button elements
+ */
+export interface ButtonElementStyles extends TextElementStyles {
+    backgroundColor?: string;
+    borderRadius?: string;
+    border?: string;
+    padding?: string;
+}
+/**
+ * Style properties for image elements
+ */
+export interface ImageElementStyles {
+    width?: string;
+    height?: string;
+    maxWidth?: string;
+}
+/**
+ * Complete captured styles for a recommendation block
+ */
+export interface CapturedStyles {
+    /** Product name text styles */
+    name: TextElementStyles;
+    /** Current price text styles */
+    price: TextElementStyles;
+    /** Original/old price text styles */
+    oldPrice: TextElementStyles;
+    /** Omnibus price text styles */
+    omnibusPrice: TextElementStyles;
+    /** Omnibus discount text styles */
+    omnibusDiscount: TextElementStyles;
+    /** CTA button styles */
+    button: ButtonElementStyles;
+    /** Product image styles */
+    image: ImageElementStyles;
+    /** Card background color */
+    cardBackgroundColor: string | null;
+    /** Column spacing in pixels */
+    columnSpacing: number;
+    /** Row spacing in pixels */
+    rowSpacing: number;
+    /** Element composition order */
+    composition: string[];
+    /** Element visibility flags */
+    visibility: Record<string, boolean>;
+}
+type DocumentModifier = {
+    modifyHtml: (node: ImmutableHtmlNode) => {
+        setStyle: (prop: string, value: string) => DocumentModifier;
+    };
+    apply: (description: ModificationDescription) => void;
+};
+/**
+ * Capture all styles from a recommendation block
+ *
+ * Call this BEFORE any operation that regenerates the block HTML.
+ * The captured styles can then be restored after regeneration.
+ * @example
+ * // Before layout change
+ * const styles = captureStyles(this.currentNode);
+ *
+ * // ... regenerate block HTML ...
+ *
+ * // After regeneration
+ * restoreStyles(this.currentNode, this.api.getDocumentModifier(), styles);
+ * @param node - The block node to capture styles from
+ * @returns Complete captured styles object
+ */
+export declare function captureStyles(node: ImmutableHtmlNode | null | undefined): CapturedStyles;
+/**
+ * Restore captured styles to a regenerated block
+ *
+ * Call this AFTER regenerating block HTML to reapply user styling.
+ * @example
+ * restoreStyles(this.currentNode, this.api.getDocumentModifier(), capturedStyles);
+ * @param node - The block node to restore styles to
+ * @param modifier - Document modifier for applying changes
+ * @param styles - Previously captured styles
+ */
+export declare function restoreStyles(node: ImmutableHtmlNode | null | undefined, modifier: DocumentModifier, styles: CapturedStyles): void;
+/**
+ * Check if styles have meaningful content worth restoring
+ * @param styles - Captured styles to check
+ * @returns True if styles contain restorable content
+ */
+export declare function hasRestorableStyles(styles: CapturedStyles): boolean;
+export {};

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

@@ -5,18 +5,14 @@
  * Handles both standard DOM properties and Stripo's custom methods.
  */
 import type { ImmutableHtmlNode } from '@stripoinc/ui-editor-extensions';
+/** Interface for nodes with standard tagName property */
+interface NodeWithTagName {
+    tagName: string;
+}
 /** Interface for nodes with getStyle method */
 export interface NodeWithGetStyle {
     getStyle: (property: string) => string | null | undefined;
 }
-/** Interface for nodes with getComputedStyle method */
-export interface NodeWithGetComputedStyle {
-    getComputedStyle: (property: string) => string | null | undefined;
-}
-/** Interface for nodes with getAttribute method */
-export interface NodeWithGetAttribute {
-    getAttribute: (name: string) => string | null;
-}
 /** Interface for nodes with parent method */
 export interface NodeWithParent {
     parent: () => ImmutableHtmlNode | null;
@@ -27,23 +23,15 @@ export interface NodeWithParent {
  */
 export declare function hasGetStyle(node: unknown): node is NodeWithGetStyle;
 /**
- * Type guard to check if a node has getComputedStyle method.
- * This is the only read that sees a background applied by Stripo's built-in
- * "Block Background Color" control — it writes neither an inline style nor a
- * queryable stylesheet rule, but the computed value is still resolvable.
- * @param node - The node to check
- */
-export declare function hasGetComputedStyle(node: unknown): node is NodeWithGetComputedStyle;
-/**
- * Type guard to check if a node has getAttribute method
+ * Type guard to check if a node has parent method
  * @param node - The node to check
  */
-export declare function hasGetAttribute(node: unknown): node is NodeWithGetAttribute;
+export declare function hasParent(node: unknown): node is NodeWithParent;
 /**
- * Type guard to check if a node has parent method
+ * Type guard to check if a node is a TD element
  * @param node - The node to check
  */
-export declare function hasParent(node: unknown): node is NodeWithParent;
+export declare function isTdNode(node: unknown): node is ImmutableHtmlNode & NodeWithTagName;
 /**
  * Safely retrieves a style value from a node
  * @param node - The node to get the style from
@@ -86,3 +74,4 @@ export declare function isTableCellNode(node: ImmutableHtmlNode | null | undefin
  * @returns The CSS display value ('table-cell' or 'table-row')
  */
 export declare function getTableDisplayValue(node: ImmutableHtmlNode | null | undefined): 'table-cell' | 'table-row';
+export {};

package/dist/src/extensions/Blocks/Unsubscribe/block.d.ts

@@ -6,6 +6,7 @@ export declare class UnsubscribeBlock extends Block {
     private cancelEventListener;
     private currentNode?;
     private linkStateByBlockId;
+    private guardAttemptsByBlockId;
     constructor();
     getId(): string;
     getIcon(): string;
@@ -15,9 +16,17 @@ export declare class UnsubscribeBlock extends Block {
     getTemplate(): string;
     getContextActionsIds(): string[];
     onSelect(node: ImmutableHtmlElementNode): void;
+    onCreated(node: ImmutableHtmlNode): void;
+    onDocumentInit(): void;
     onDocumentChanged(node: ImmutableHtmlNode): void;
     onDelete(node: ImmutableHtmlElementNode): void;
     onDestroy(): void;
+    /**
+     * Guarantees a plain-text node before the link's wrapper inside the <p>.
+     * Without it the only caret position left of the link is inside the anchor,
+     * so anything typed there becomes part of the link (SD-143097).
+     */
+    private _ensureLeadingTextGuard;
     private _hasUnsubscribeLink;
     private _readBlockId;
     /**

package/dist/src/extensions/Blocks/controlFactories.d.ts

@@ -280,21 +280,11 @@ export declare function createButtonTextStyleAndFontColorControl(controlId: stri
     new (): {
         getId(): string;
         getTargetNodes(root: ImmutableHtmlNode): ImmutableHtmlNode[];
-        /**
-         * Propagates Bold/Italic to ALL product buttons, not just the focused one.
-         *
-         * Stripo's built-in applies font-color/size to every target node but writes
-         * the text-style (font-weight/font-style) only to the selected button. Bold/italic
-         * are plain inline CSS on the `<a class="es-button">` (no tags), so we mirror them
-         * onto every button's anchor. The toggle state comes from the control's form
-         * (`buttonTextStyleForm.{bold,italic}`) because the patched node isn't updated yet
-         * when this runs. Returned modifications are merged into the parent control's patch.
-         */
-        getAdditionalModifications(root: ImmutableHtmlNode): import("@stripoinc/ui-editor-extensions").TemplateModifier<import("@stripoinc/ui-editor-extensions").HtmlNodeModifier, import("@stripoinc/ui-editor-extensions").CssNodeModifier> | undefined;
         getParentControlId(): string;
         getLabels(): import("@stripoinc/ui-editor-extensions").ButtonTextStyleAndFontColorControlLabels | undefined;
         api: import("@stripoinc/ui-editor-extensions").ControlApi;
         getModificationDescription(): import("@stripoinc/ui-editor-extensions").ModificationDescription | undefined;
+        getAdditionalModifications(_root: ImmutableHtmlNode): import("@stripoinc/ui-editor-extensions").TemplateModifier<import("@stripoinc/ui-editor-extensions").HtmlNodeModifier, import("@stripoinc/ui-editor-extensions").CssNodeModifier> | undefined;
         isVisible(_node: ImmutableHtmlNode): boolean;
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useinsider/guido",
-  "version": "3.6.0-beta.596b70e",
+  "version": "3.6.0-beta.5cbaa8f",
   "description": "Guido is a Vue + TypeScript wrapper for Email Plugin. Easily embed the email editor in your Vue applications.",
   "main": "./dist/guido.umd.cjs",
   "module": "./dist/library.js",

package/dist/extensions/Blocks/Recommendation/utils/captureStyleTemplates.js

@@ -1,139 +0,0 @@
-import { RecommendationBlockId as i } from "../constants/blockIds.js";
-import { DESKTOP_CONTAINER_SELECTOR as S, ATTR_PRODUCT_NAME as _, ATTR_PRODUCT_PRICE as C, ATTR_PRODUCT_OLD_PRICE as I, ATTR_PRODUCT_OMNIBUS_PRICE as O, ATTR_PRODUCT_OMNIBUS_DISCOUNT as k, ATTR_PRODUCT_BUTTON as A, ATTR_PRODUCT_IMAGE as E } from "../constants/selectors.js";
-import { extractWrapperTags as g } from "./preserveTextStyles.js";
-import { hasGetStyle as f, hasGetAttribute as P, hasGetComputedStyle as h } from "./tagName.js";
-const c = [
-  "font-size",
-  "font-family",
-  "font-weight",
-  "font-style",
-  "color",
-  "text-align",
-  "line-height",
-  "text-decoration"
-], B = [
-  "background",
-  "background-color",
-  "border-width",
-  "border-color",
-  "border-style",
-  "border-radius"
-], N = [
-  ...c,
-  "background",
-  "background-color",
-  "padding",
-  "width",
-  "mso-border-alt",
-  "mso-padding-alt"
-], U = [
-  "display",
-  "width",
-  "height",
-  "max-width",
-  "border-radius",
-  "margin"
-], l = /* @__PURE__ */ new Set(["transparent", "rgba(0, 0, 0, 0)"]), q = [
-  { attrKey: _, blockId: i.NAME, kind: "text" },
-  { attrKey: C, blockId: i.PRICE, kind: "text" },
-  { attrKey: I, blockId: i.OLD_PRICE, kind: "text" },
-  { attrKey: O, blockId: i.OMNIBUS_PRICE, kind: "text" },
-  { attrKey: k, blockId: i.OMNIBUS_DISCOUNT, kind: "text" },
-  { attrKey: A, blockId: i.BUTTON, kind: "button" },
-  { attrKey: E, blockId: i.IMAGE, kind: "image" }
-];
-function y(t) {
-  return t && "getInnerHTML" in t && typeof t.getInnerHTML == "function" ? t.getInnerHTML().trim() : "";
-}
-function a(t, r, e) {
-  !r || !f(r) || e.forEach((o) => {
-    const n = r.getStyle(o);
-    n && n !== "inherit" && n !== "initial" && (t[o] = n);
-  });
-}
-function b(t) {
-  return Object.entries(t).map(([r, e]) => `${r}: ${e};`).join(" ");
-}
-function p(t) {
-  if (!t || !f(t))
-    return;
-  const r = t.getStyle("background-color") || t.getStyle("background");
-  return r && !l.has(r) ? r : void 0;
-}
-function d(t, r) {
-  const e = {};
-  return a(e, t, r), b(e);
-}
-function M(t) {
-  const r = t.querySelector("p"), e = {};
-  a(e, t, c), a(e, r, c), a(e, t.querySelector("strong"), c), a(e, t.querySelector("em"), c), a(e, t.querySelector("s"), c);
-  const o = b(e), { openTags: n, closeTags: u } = g(y(r));
-  return !o && !n ? null : { pStyle: o || void 0, openTags: n, closeTags: u };
-}
-function x(t) {
-  const r = t.querySelector(".es-button-border"), e = t.querySelector("a.es-button") ?? t.querySelector("a"), o = d(r, B), n = d(e, N), u = r && "getAttribute" in r ? r.getAttribute("class") ?? "" : "", s = /\bes-fw\b/.test(u), { openTags: T, closeTags: R } = g(y(e));
-  return !o && !n && !s && !T ? null : {
-    buttonBorderStyle: o || void 0,
-    buttonAnchorStyle: n || void 0,
-    buttonFitToContainer: s || void 0,
-    openTags: T,
-    closeTags: R
-  };
-}
-function D(t) {
-  const r = d(t.querySelector("img"), U);
-  return r ? { imgStyle: r } : null;
-}
-function v(t, r) {
-  return r === "button" ? x(t) : r === "image" ? D(t) : M(t);
-}
-function m(t, r) {
-  if (!t || !("querySelector" in t))
-    return;
-  const e = t.querySelector(S) ?? t;
-  q.forEach(({ attrKey: o, blockId: n, kind: u }) => {
-    const s = e.querySelector(`[esd-extension-block-id="${n}"]`);
-    s && r(s, o, u);
-  });
-}
-function F(t) {
-  const r = {};
-  return m(t, (e, o, n) => {
-    if (!("querySelector" in e))
-      return;
-    const u = v(e, n);
-    u && (r[o] = u);
-  }), r;
-}
-function $(t) {
-  if (!t || !("querySelector" in t))
-    return;
-  const r = t.querySelector(S) ?? t, e = r.querySelector(".product-card-segment") ?? r.querySelector(".product-card-wrapper");
-  return p(e);
-}
-function K(t) {
-  if (!t)
-    return;
-  const r = P(t) ? t.getAttribute("bgcolor") : null;
-  if (r && !l.has(r))
-    return r;
-  const e = p(t);
-  if (e)
-    return e;
-  const o = h(t) ? t.getComputedStyle("background-color") : void 0;
-  return o && !l.has(o) ? o : void 0;
-}
-function j(t) {
-  const r = {};
-  return m(t, (e, o, n) => {
-    if (n !== "text")
-      return;
-    const u = K(e);
-    u && (r[o] = u);
-  }), r;
-}
-export {
-  F as captureAttributeStyleTemplates,
-  $ as captureCardBackgroundColor,
-  j as captureCellBackgroundColors
-};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,44 +0,0 @@
-/**
- * Capture Style Templates
- *
- * Reads the user-applied styling of each text attribute from the LIVE block DOM
- * and turns it into per-attribute `AttributeStyleTemplate`s that the template
- * renderers bake straight into regenerated HTML.
- *
- * Why this exists: a full regeneration replaces product cells via `setInnerHtml`.
- * Querying the new cells to re-apply styles after `apply()` requires a second
- * (deferred) commit, and multiple commits corrupt Stripo's selection tracking
- * (the `textContent` crash). Baking the captured styles into the HTML keeps the
- * whole regeneration a SINGLE `setInnerHtml` + SINGLE `apply()`.
- *
- * Inline formats (bold/italic/strike) are captured as TAGS (`<strong>/<em>/<s>`),
- * not CSS, because Stripo applies and detects them as tags — re-emitting
- * `text-decoration` CSS would render a strike its own toggle can't see.
- */
-import type { AttributeStyleTemplates } from '../templates/utils';
-import type { ImmutableHtmlNode } from '@stripoinc/ui-editor-extensions';
-/**
- * Captures per-attribute style templates (text + button + image) from the block's desktop
- * container. Scoped to desktop so the mobile container's duplicate block ids aren't read.
- * Returns only the attributes that actually have styling worth preserving.
- */
-export declare function captureAttributeStyleTemplates(node: ImmutableHtmlNode | null | undefined): AttributeStyleTemplates;
-/**
- * Captures the card background color (the "Styles" tab control) from the first card
- * container — `.product-card-segment` in grid, `.product-card-wrapper` in list. Returns
- * undefined when unset/transparent so the renderer keeps its (bg-less) default.
- */
-export declare function captureCardBackgroundColor(node: ImmutableHtmlNode | null | undefined): string | undefined;
-/**
- * Captures each text attribute's "Block Background Color" (Styles tab) from the block's
- * desktop container, keyed by ATTR_PRODUCT_* composition key. The renderers bake these
- * straight onto the regenerated `[esd-extension-block-id]` cell so the bg survives a full
- * regeneration — unlike the card background, the text-cell bg lives on the attribute cell
- * itself and is only readable via `getComputedStyle` (see `readCellBackground`). Returns
- * only the attributes that actually carry a non-transparent background.
- *
- * Scope note: custom attributes (`customAttr:*`) share the single CUSTOM_ATTRIBUTE block id
- * and aren't in `CAPTURE_TARGETS`, so their bg is applied live but not preserved here — same
- * boundary as `captureAttributeStyleTemplates`.
- */
-export declare function captureCellBackgroundColors(node: ImmutableHtmlNode | null | undefined): Record<string, string>;

package/dist/src/extensions/Blocks/Recommendation/utils/captureStyleTemplates.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export {};