pagepilot-visual-editor 1.0.25 → 1.0.27

package/dist/editor-sample/documents/blocks/helpers/InlineTextToolbar/hooks/useToolbarCommands.d.ts

@@ -1,4 +1,5 @@
 import { LinkInsertParams } from '../types';
+export type FontSizeDevice = 'desktop' | 'tablet' | 'mobile';
 /** Snapshot of an existing anchor under the saved/live selection — populated
  *  by `getSavedSelectionLink` and used by the Link dialog to prefill its
  *  fields when the user opens the dialog while standing on a link. */
@@ -23,7 +24,22 @@ export type ToolbarCommandsApi = {
      * onChange tick.
      */
     applyColor: (cmd: string, value: string) => void;
-    applyFontSize: (px: number) => void;
+    /**
+     * Set the font size for the current selection at the given device slot.
+     * Writes `data-fs-<device>="<px>"` on a wrapping <span> so responsive CSS
+     * rules (see the Text block renderer + responsiveFontSizeCss.ts) can pick
+     * the correct size per preview device / breakpoint. Preserves any
+     * pre-existing device markers on the same range so setting Mobile doesn't
+     * clobber Desktop.
+     */
+    applyFontSize: (px: number, device: FontSizeDevice) => void;
+    /**
+     * Remove the size override for one device on the current selection. If the
+     * span was carrying no other device markers, the wrapper is unwrapped so
+     * the block-level font size shows through. Leaves other devices' markers
+     * intact.
+     */
+    clearFontSize: (device: FontSizeDevice) => void;
     /** Set CSS line-height on every block-level ancestor the current selection
      *  touches. Pass an empty string to clear back to the inherited default. */
     applyLineHeight: (value: string) => void;

package/dist/editor-sample/documents/blocks/helpers/InlineTextToolbar/popovers/ResponsiveFontSizePopover.d.ts

@@ -0,0 +1,43 @@
+import { FontSizeDevice } from '../hooks/useToolbarCommands';
+type ResponsiveFontSizePopoverProps = {
+    /**
+     * Currently-applied per-device values, read from the nearest wrapping
+     * responsive span at the caret. Empty string means "no override for this
+     * device" — the block-level font size shows through.
+     */
+    values: {
+        desktop: string;
+        tablet: string;
+        mobile: string;
+    };
+    /** Block-level size (from `fmt.fontSize`) — shown in the trigger when no
+     *  per-device override exists so the label matches the pre-responsive
+     *  behavior of the single font-size dropdown. */
+    fallbackSize: string;
+    /** Which device tab should open by default. Wired to the canvas's
+     *  currently-previewed device so the popover lands on whatever the user is
+     *  looking at. */
+    initialDevice: FontSizeDevice;
+    /** Write a size to `data-fs-<device>` on the current selection's span. */
+    onApply: (px: number, device: FontSizeDevice) => void;
+    /** Remove `data-fs-<device>` from the current selection's span. */
+    onClear: (device: FontSizeDevice) => void;
+};
+/**
+ * Font-size control that lets the user set a distinct size per device
+ * (Desktop / Tablet / Mobile) on the current selection. Layout:
+ *
+ *   [ 40 ▾ ]                              ← trigger (compact summary)
+ *   └─ popover ────────────────────────────
+ *      | 🖥  Desktop   40 · Clear         |
+ *      | 📱 Tablet    Not set             |   ← device rows
+ *      | 📱 Mobile    24 · Clear          |
+ *      | ─────────────────────────────    |
+ *      | ✓ 10  12  14 …                   |   ← size list for the active row
+ *
+ * The device rows act as radio-style tabs — clicking one selects it as the
+ * "active" row and highlights its current value in the size list below. The
+ * size list writes to whichever device the active row represents.
+ */
+export declare function ResponsiveFontSizePopover({ values, fallbackSize, initialDevice, onApply, onClear, }: ResponsiveFontSizePopoverProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editor-sample/documents/blocks/helpers/InlineTextToolbar/types.d.ts

@@ -2,6 +2,7 @@ export type ToolbarPosition = {
     top: number;
     left: number;
 };
+export declare const LINK_COLOR = "#2563eb";
 export type FormatSnapshot = {
     bold: boolean;
     italic: boolean;
@@ -18,6 +19,12 @@ export type FormatSnapshot = {
     blockLabel: string;
     fontName: string;
     fontSize: string;
+    /** Per-device font-size override read from the nearest wrapping
+     *  `<span data-fs-*>` at the caret. Empty string means no override for
+     *  that device — the block-level `fontSize` shows through. */
+    fontSizeDesktop: string;
+    fontSizeTablet: string;
+    fontSizeMobile: string;
     /** Unitless multiplier (e.g. "1.5") if the block carries an inline
      *  line-height; empty string when the block inherits its default. */
     lineHeight: string;

package/dist/editor-sample/documents/blocks/helpers/documentUtils.d.ts

@@ -41,8 +41,8 @@ export type RepeatableSlot = {
 };
 export type RepeatableContainerInfo = {
     containerId: string;
-    type: 'Grid' | 'FlexColumns' | 'Carousel';
-    /** Total fixed slots (grid cells / flex columns / carousel slides). */
+    type: 'Grid' | 'FlexColumns' | 'Carousel' | 'Marquee' | 'Pagination' | 'TabsBlock';
+    /** Total fixed slots (grid cells / flex columns / carousel slides / tab panels). */
     slotCount: number;
     /** Each slot's current child ids, normalized to `slotCount` length. */
     slots: RepeatableSlot[];
@@ -62,6 +62,97 @@ export declare function getRepeatableContainerInfo(documentTree: Record<string,
 /** Write a container's slots back onto the block (Grid → cells, Carousel →
  *  items[].contentChildrenIds, else → columns). */
 export declare function writeContainerSlots(block: any, slots: RepeatableSlot[]): any;
+export type ItemsArrayInfo = {
+    blockId: string;
+    type: string;
+    items: Record<string, any>[];
+};
+/** True if the block's repeatable content is a flat `props.items` array (no child blocks). */
+export declare function isItemsArrayBlockType(type: string | undefined): boolean;
+/**
+ * Describe an items-array block's current items. Returns null when the block
+ * isn't a supported items-array type. Used by the Variables tab to decide
+ * whether to show the items data-source controls for the selected block.
+ */
+export declare function getItemsArrayInfo(documentTree: Record<string, any>, blockId: string): ItemsArrayInfo | null;
+/** Write an items-array block's `items` back onto the block. */
+export declare function writeItemsArray(block: any, items: Record<string, any>[]): any;
+export type VariableGroupKind = 'container' | 'itemsArray' | 'block' | 'page';
+export type VariableGroup = {
+    /** Stable identity for selection — the owning block id, or `page` for page-level. */
+    id: string;
+    kind: VariableGroupKind;
+    /** Block id to select on the canvas when the group is opened. Null for page-level. */
+    blockId: string | null;
+    /** Block type (`Grid`, `FlexColumns`, …) — drives the list row's icon. Null for page-level. */
+    blockType: string | null;
+    /** How many variable fields this group holds. */
+    fieldCount: number;
+    /** Repeat slot total, when the group is a slot container. */
+    slotCount?: number;
+    /**
+     * Field names in this group, in order — rendered as the card's preview so
+     * the user can tell two same-type groups apart by their CONTENT rather than
+     * by a positional number.
+     */
+    fieldNames: string[];
+    /**
+     * True when the block is a repeatable container the author has NOT set up
+     * yet — no field, no Repeat toggle, no row tokens. It owns nothing to edit,
+     * but its Repeat toggle is only reachable from its own screen, so it is
+     * listed separately rather than dropped. See `isVariableBoundBlock`.
+     */
+    isCandidate?: boolean;
+};
+/**
+ * The block a field belongs to, or null when the field is page-level.
+ *
+ * `sourceBlockId` points at the template block sitting INSIDE a container slot,
+ * not at the container itself — and in practice `containerId` is usually absent
+ * (the repeat flow only ever writes `sourceBlockId`). So a source block is
+ * walked UP to its owning repeatable container: that container is what the user
+ * thinks of as "the group", and grouping by the raw `sourceBlockId` would both
+ * split one grid into a row per slot and fail every `getRepeatableContainerInfo`
+ * lookup downstream.
+ *
+ * A source block with no repeatable ancestor is a plain (non-repeatable) block
+ * with variables — it stays its own group, keyed on itself.
+ */
+export declare function getFieldOwnerBlockId(documentTree: Record<string, any>, field: {
+    containerId?: string;
+    sourceBlockId?: string;
+    itemsBlockId?: string;
+}): string | null;
+/**
+ * Cheap structural fingerprint of everything `collectVariableGroups` actually
+ * reads: each block's `type` + every child-id array (the `collectSubtreeIds`
+ * walk) + the slot-count props Grid/Pagination use, plus each field's owner ids
+ * / name / type. Text edits, colour/style tweaks, `data.style`, block `props`
+ * that aren't structural — none of it moves this string. Memo the group list on
+ * this instead of the whole `document` so ~90% of editor keystrokes skip the
+ * full tree re-scan.
+ *
+ * Must list the SAME shapes `collectSubtreeIds` + `readContainerSlots` walk —
+ * if a new container child-array is added there, mirror it here or the list can
+ * go stale until an unrelated structural edit flushes it.
+ */
+export declare function variableGroupsStructuralKey(documentTree: Record<string, any>, fields: Array<{
+    id?: string;
+    name?: string;
+    type?: string;
+    containerId?: string;
+    sourceBlockId?: string;
+    itemsBlockId?: string;
+}>): string;
+export declare function collectVariableGroups(documentTree: Record<string, any>, fields: Array<{
+    id?: string;
+    name?: string;
+    type?: string;
+    value?: unknown;
+    containerId?: string;
+    sourceBlockId?: string;
+    itemsBlockId?: string;
+}>): VariableGroup[];
 /**
  * Grow a repeatable container so it has at least `neededSlots` cells/columns/slides.
  *

package/dist/editor-sample/documents/blocks/helpers/responsiveFontSizeCss.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Global stylesheet that makes per-span `data-fs-<device>` attributes render
+ * at the picked size.
+ *
+ * The inline toolbar writes attributes only — no `style="font-size:…"` — so
+ * a single span can carry three independent sizes (Desktop / Tablet / Mobile)
+ * without fighting over a single inline slot. This module owns the CSS that
+ * turns those attributes into a live font-size.
+ *
+ * Rendering paths and how each finds the right rule:
+ *
+ *   Real page viewport:  `@media (max-width: 640px) { [data-fs-mobile="24"] … }`
+ *     Fires on real pages where the browser viewport width is truthful. The
+ *     published page loads its viewport-driven CSS this way.
+ *
+ *   Editor canvas simulation:  `@container ahd-page (max-width: 640px) …`
+ *     The editor fakes device widths by RESIZING the `.ahd-page-root` box
+ *     (378px mobile / 720px tablet) inside a full-width browser, so plain
+ *     `@media` never fires in the editor. `.ahd-page-root` is set up as a
+ *     `container-type: inline-size; container-name: ahd-page` context (see
+ *     renderDynamicCss.ts), which `@container ahd-page (max-width: …)`
+ *     queries against — so the same rule table works in both places.
+ *
+ * Emitting both queries around identical rule bodies is the shared pattern
+ * across the codebase (see MenuPicker, FlexColumns, EmailLayout responsive
+ * helpers). Desktop rules stay unscoped so they always apply as the base.
+ *
+ * The rule table is static (22 sizes × 3 devices × two queries) so no
+ * per-render work happens — the stylesheet is injected once into
+ * `document.head` on first import.
+ */
+export declare const RESPONSIVE_FONT_SIZE_CSS: string;
+export declare function buildExtraResponsiveFontSizeCss(html: string): string;
+/**
+ * Injects the responsive font-size stylesheet into `document.head` exactly
+ * once per document. Safe to call from any block renderer's top-level
+ * module load — a second call is a no-op if the element already exists.
+ */
+export declare function ensureResponsiveFontSizeCssInjected(): void;
+/**
+ * Collapse chains of nested `<span data-fs-*>` wrappers so a single span
+ * carries all three device markers.
+ *
+ * A previous version of applyFontSize wrapped each write in a fresh <font
+ * size="7"> which turned into a fresh <span data-fs-<device>>. Applying
+ * three device sizes in a row produced three concentric spans, one per
+ * device, each seeing only its own attribute — which broke both the
+ * per-device readback (readLiveFormat surfaced only the innermost) and
+ * the published-page cascade (the outermost span's unscoped desktop rule
+ * shadowed inner mobile/tablet markers on their respective breakpoints).
+ *
+ * Runs on the editor DOM whenever it renders, so any legacy nested
+ * content authored under the old code path heals in place the moment it
+ * flows through this normalizer. Idempotent.
+ *
+ * The merge rule: if a responsive span has exactly one responsive-span
+ * child and no non-whitespace text siblings alongside that child, fold the
+ * two together. Attributes already on the child win over the parent's for
+ * the same device slot (the child was written more recently).
+ */
+export declare function normalizeResponsiveSpans(root: HTMLElement | null): void;
+/**
+ * Copy the parent responsive span's inline style properties and class onto the
+ * child before the parent is unwrapped. Child values win, so the more
+ * recently-authored inner span keeps its own choices; the parent's `font-size`
+ * is skipped because per-device sizing is driven by `data-fs-*` + CSS rules.
+ *
+ * Exported so `applyFontSize` in the inline toolbar can share the exact same
+ * merge behavior when its slow-path parent-merge loop collapses nested
+ * responsive spans it just produced.
+ */
+export declare function mergeStylingFromParent(parent: HTMLElement, child: HTMLElement): void;

package/dist/editor-sample/documents/blocks/helpers/variableBinding.d.ts

@@ -0,0 +1,5 @@
+export declare function subtreeHasRowTokens(documentTree: Record<string, any>, rootId: string): boolean;
+/** True if the author has switched the block's Repeat toggle on. */
+export declare function hasRepeatEnabled(block: any): boolean;
+export declare function isVariableBoundBlock(documentTree: Record<string, any>, blockId: string, fieldOwnerIds: Set<string>): boolean;
+export declare function classifyVariableBlock(documentTree: Record<string, any>, blockId: string, fieldOwnerIds: Set<string>): 'bound' | 'candidate' | 'none';

package/dist/editor-sample/documents/editor/core.d.ts

@@ -475,8 +475,14 @@ export declare const EditorBlock: ({ type, data }: import('@usewaypoint/document
                 left: z.ZodNumber;
             }, z.core.$strip>>>;
             tabActiveColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            tabActiveBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            tabInactiveTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            tabInactiveBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            tabInactiveBorderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            tabInactiveBorderWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
             tabTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
             tabBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            tabBorderRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
             tabGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
             contentGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
             navBorderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
@@ -505,6 +511,14 @@ export declare const EditorBlock: ({ type, data }: import('@usewaypoint/document
                 showSelectedSection: "showSelectedSection";
                 scrollToSelectedSection: "scrollToSelectedSection";
             }>>>;
+            tabsAlign: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+                right: "right";
+                left: "left";
+                center: "center";
+            }>>>;
+            dropdown: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+            dropdownTablet: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+            dropdownMobile: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
             activeTabIndex: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
             stickyNav: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
             items: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -1026,6 +1040,7 @@ export declare const EditorBlock: ({ type, data }: import('@usewaypoint/document
             height: z.ZodDefault<z.ZodString>;
             heightTablet: z.ZodOptional<z.ZodString>;
             heightMobile: z.ZodOptional<z.ZodString>;
+            autoHeight: z.ZodDefault<z.ZodBoolean>;
             alignment: z.ZodDefault<z.ZodEnum<{
                 right: "right";
                 left: "left";
@@ -2132,8 +2147,8 @@ export declare const EditorBlock: ({ type, data }: import('@usewaypoint/document
         }, z.core.$strip>>>;
         props: z.ZodNullable<z.ZodOptional<z.ZodObject<{
             stepperType: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
-                both: "both";
                 numeric: "numeric";
+                both: "both";
                 dots: "dots";
             }>>>;
             totalDots: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
@@ -2186,8 +2201,8 @@ export declare const EditorBlock: ({ type, data }: import('@usewaypoint/document
             marker: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
                 none: "none";
                 check: "check";
-                square: "square";
                 circle: "circle";
+                square: "square";
                 decimal: "decimal";
                 disc: "disc";
                 dash: "dash";

package/dist/editor-sample/documents/editor/templateVariables.d.ts

@@ -1,9 +1,9 @@
 import { TEditorConfiguration } from './core';
 import { TemplateFormField } from '../../../render-core/templateBaking';
-export { bakeTemplateValues, substituteBlockText, applyVariables, buildRepeatRowIndex, getTemplateForms, getTextFieldsForType, } from '../../../render-core/templateBaking';
+export { bakeTemplateValues, substituteBlockText, applyVariables, buildRepeatRowIndex, getTemplateForms, getTextFieldsForType, TEMPLATE_SCALAR_TYPES, } from '../../../render-core/templateBaking';
 export type { TemplateScalarType, TemplateFormType, TemplateItemFieldDef, TemplateArrayRow, TemplateFormField, } from '../../../render-core/templateBaking';
-/** All scalar types — used by both top-level fields and array sub-fields. */
-export declare const TEMPLATE_SCALAR_TYPES: Array<'text' | 'textarea' | 'number' | 'image'>;
+export type { DateFormatPreset, TimeFormatPreset } from '../../../render-core/dateFormats';
+export { DATE_FORMAT_PRESETS, DEFAULT_DATE_FORMAT, DEFAULT_TIME_FORMAT, formatDateValue, formatRelativeDate, formatTimeValue, TIME_FORMAT_PRESETS, } from '../../../render-core/dateFormats';
 /**
  * Apply `sourceHtml`'s formatting shell to `targetHtml`'s text. If the source
  * has no formatting, returns the target unchanged (keeps the copy's text as-is).

package/dist/email-builder-core/blocks/FormsPicker/FormsPropsSchema.d.ts

@@ -9,6 +9,7 @@ export declare const FormsPropsSchema: z.ZodObject<{
         height: z.ZodDefault<z.ZodString>;
         heightTablet: z.ZodOptional<z.ZodString>;
         heightMobile: z.ZodOptional<z.ZodString>;
+        autoHeight: z.ZodDefault<z.ZodBoolean>;
         alignment: z.ZodDefault<z.ZodEnum<{
             right: "right";
             left: "left";

package/dist/email-builder-core/blocks/TabsBlock/TabsBlockPropsSchema.d.ts

@@ -31,8 +31,14 @@ export declare const TabsBlockPropsSchema: z.ZodObject<{
             left: z.ZodNumber;
         }, z.core.$strip>>>;
         tabActiveColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabActiveBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabInactiveTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabInactiveBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabInactiveBorderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabInactiveBorderWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         tabTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         tabBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabBorderRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         tabGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         contentGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         navBorderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
@@ -61,6 +67,14 @@ export declare const TabsBlockPropsSchema: z.ZodObject<{
             showSelectedSection: "showSelectedSection";
             scrollToSelectedSection: "scrollToSelectedSection";
         }>>>;
+        tabsAlign: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            right: "right";
+            left: "left";
+            center: "center";
+        }>>>;
+        dropdown: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        dropdownTablet: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        dropdownMobile: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
         activeTabIndex: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         stickyNav: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
         items: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{

package/dist/email-builder-core/renderers/pageScripts.d.ts

@@ -1,4 +1,5 @@
 import { TReaderDocument } from '../Reader/core';
+export declare const buildTemplateVarSubstitutionMarkup: () => string;
 export declare const hasTabsBlock: (document: TReaderDocument) => boolean;
 export declare const hasDemoBlock: (document: TReaderDocument) => boolean;
 export declare const hasCarouselBlock: (document: TReaderDocument) => boolean;

package/dist/email-builder-core/utils/substituteTemplateVars.d.ts

@@ -0,0 +1,32 @@
+export declare const TEMPLATE_VAR_ATTR = "data-ahd-var";
+export declare function markTemplateVarsInHtml(html: string): string;
+export declare function markTemplateVarsInPlainText(value: string): string;
+export declare function fillTemplateVarsInUrlString(url: string, search?: string): string;
+export declare function fillTemplateVarSpans(root: ParentNode, search?: string): void;
+export declare const TEMPLATE_DATE_ATTR = "data-ahd-date";
+export declare const TEMPLATE_DATE_FORMAT_ATTR = "data-ahd-date-format";
+/**
+ * Marker span for a relative date token. Carries the raw ISO in `data-ahd-date`
+ * and `data-ahd-date-format="relative"`. Its text content is the label computed
+ * NOW (so the editor canvas and any non-runtime render already read sensibly);
+ * the client / saved-HTML runtime overwrites it on view so "Today" stays
+ * accurate on later opens. `data-ahd-var` is kept so the orphan-token / pill
+ * machinery still recognises the span.
+ */
+export declare function markDateVar(name: string, isoValue: string): string;
+/**
+ * "Today" | "Tomorrow" | "Yesterday" | weekday | "Mmm D" | "Mmm D, YYYY",
+ * compared against `now` in the host's local timezone. Standalone (no imports)
+ * so the saved-HTML runtime in pageScripts.ts can inline the same logic.
+ *
+ * NOTE: keep in sync with formatRelativeDate in src/utils/dateFormats.ts and the
+ * inlined copy in pageScripts.ts (buildTemplateVarSubstitutionMarkup).
+ */
+export declare function formatRelativeDateLabel(iso: string, now?: Date): string;
+/**
+ * Client-side fill for relative-date markers within `root`. Runs alongside
+ * fillTemplateVarSpans in the Reader's layout effect. Idempotent — re-running
+ * re-reads the ISO from the attribute, so it's safe to call on every document
+ * change.
+ */
+export declare function fillDateVarSpans(root: ParentNode, now?: Date): void;

package/dist/host-stubs/view/shared/common/InfoTooltip.d.ts

@@ -0,0 +1,19 @@
+export interface InfoTooltipLink {
+    label: string;
+    href: string;
+}
+interface InfoTooltipProps {
+    text: string;
+    link?: InfoTooltipLink;
+    placement?: 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+    iconSize?: number;
+}
+/**
+ * Common help-icon tooltip, ported from ahd-fe's host-app copy (which lives
+ * outside the email-builder package, at `src/view/shared/common/InfoTooltip.tsx`,
+ * and resolves relative links against a host-only `PRODUCT_DOCS_BASE_URL`
+ * constant VE doesn't have). Callers here pass a full `https://` URL instead —
+ * see VariablesPanel's `DOCS_TEMPLATE_VARIABLES` for the same convention.
+ */
+declare const InfoTooltip: React.FC<InfoTooltipProps>;
+export default InfoTooltip;

package/dist/host-stubs/view/shared/timeZones.d.ts

@@ -0,0 +1,4 @@
+export declare const timeZoneOptions: {
+    value: string;
+    label: string;
+}[];