@maildeno/editor 0.1.0

package/dist/adapters/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The storage adapter interface. This is the actual product boundary — see
+ * the project README's "Positioning" section: the editor is MIT-licensed
+ * and fully functional against createLocalStorageAdapter() below, with zero
+ * backend. A hosted adapter (implementing the same interface against a real
+ * API) is a separate package, not part of this one.
+ *
+ * Deliberately does NOT cover useEmailBuilderPersistence's autosave draft —
+ * that's a single-slot, 30-day-TTL crash-recovery buffer that's always
+ * localStorage regardless of which adapter is active (explicitly designed
+ * to be cleared once a "real" save happens through this interface, not a
+ * replacement for it). Confirmed still wired and working via Header.vue's
+ * initFromStorage() call — untouched by this batch.
+ */
+export interface TemplateSnapshot {
+    rows: Record<string, any>[];
+    canvasStyles: Record<string, any>;
+    name?: string;
+    tags?: string[];
+    updatedAt?: string;
+}
+/** One entry in the saved-templates list. Deliberately a summary, not a full
+ *  TemplateSnapshot — listing shouldn't require loading every template's rows,
+ *  which for a cloud adapter would mean fetching entire documents just to
+ *  render a list. Selecting one calls loadTemplate(id) for the real content. */
+export interface TemplateSummary {
+    templateId: string;
+    name?: string;
+    updatedAt?: string;
+}
+export interface SavedRow {
+    id: string;
+    name: string;
+    createdAt: string;
+    row: Record<string, any>;
+}
+export interface EditorStorageAdapter {
+    loadTemplate(templateId?: string): Promise<TemplateSnapshot | null>;
+    saveTemplate(snapshot: TemplateSnapshot, templateId?: string): Promise<{
+        templateId: string;
+    }>;
+    /**
+     * Lists saved templates for the saved-templates panel.
+     *
+     * Optional on purpose: adding it as a required method would break every
+     * adapter already written against this interface. When absent, the panel
+     * says so rather than appearing broken — the same capability-gating used
+     * for onSendTestEmail, where a feature that can't be backed simply isn't
+     * offered.
+     */
+    listTemplates(): Promise<TemplateSummary[]>;
+    /** Optional, and only surfaced in the panel when implemented. */
+    deleteTemplate(templateId: string): Promise<void>;
+    listSavedRows(): Promise<SavedRow[]>;
+    saveSavedRow(row: Record<string, any>, name: string): Promise<SavedRow | null>;
+    deleteSavedRow(id: string): Promise<void>;
+    renameSavedRow(id: string, name: string): Promise<void>;
+    cloneSavedRowForCanvas(id: string): Record<string, any> | null;
+    uploadImage(file: File): Promise<string>;
+}
+/**
+ * What a host actually passes as `storageAdapter`.
+ *
+ * Every method is optional. Anything you leave out falls back to the
+ * built-in localStorage adapter, so you can override only the parts you
+ * care about:
+ *
+ * ```ts
+ * // Upload images to your own storage; keep everything else local.
+ * init({ storageAdapter: { uploadImage: (file) => uploadToS3(file) } });
+ * ```
+ *
+ * Internally the editor always works with a complete `EditorStorageAdapter`
+ * — `provideStorageAdapter` merges your partial over the defaults — so no
+ * call site has to guard against a missing method.
+ *
+ * One thing worth knowing: the fallback is per-method, not per-area. If you
+ * implement `saveTemplate` against your own backend but leave
+ * `listTemplates` out, the saved-templates panel will list whatever is in
+ * localStorage rather than your backend. The editor warns about that
+ * specific mismatch in development.
+ */
+export type PartialStorageAdapter = Partial<EditorStorageAdapter>;

package/dist/baseStyles.d.ts

@@ -0,0 +1,13 @@
+/** Tailwind, the editor's own CSS and the Satoshi font, as independent CSS
+ *  strings — each becomes its own <style> tag wherever the caller injects them. */
+export declare function getBaseStyles(): string[];
+/**
+ * Injects getBaseStyles() directly into document.head, exactly once no
+ * matter how many times it's called — called from EmailEditor.vue on
+ * every mount, so multiple <EmailEditor> instances on one page (or one
+ * instance unmounting and remounting) don't each inject a duplicate copy.
+ * Genuinely module-level, not per-component-instance state: this file is
+ * only ever evaluated once, the first time anything imports it, regardless
+ * of how many EmailEditor instances get created afterward.
+ */
+export declare function injectBaseStylesIntoHead(): void;

package/dist/blocks/canvasStyleHelpers.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+/**
+ * Applies mobile prop overrides when in mobile preview mode. Depends on
+ * previewMode, not just the component's own props — extracted verbatim
+ * from CanvasComponent.vue's local resolveProps.
+ */
+export declare function resolveMobileProps(p: any, previewMode: Ref<string>): any;
+/** Extracted verbatim from CanvasComponent.vue's local resolveBackground. */
+export declare function resolveBackground(p: any): string;
+/**
+ * Desktop/mobile-hide opacity class — extracted verbatim from
+ * CanvasComponent.vue's local hideClass computed.
+ */
+export declare function useHideClass(componentProps: Ref<{
+    mobileHide?: boolean;
+    desktopHide?: boolean;
+}>, previewMode: Ref<string>): import('vue').ComputedRef<string[]>;

package/dist/blocks/definitions/anchor.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const anchorBlock: BlockDefinition;

package/dist/blocks/definitions/button.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const buttonBlock: BlockDefinition;

package/dist/blocks/definitions/divider.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const dividerBlock: BlockDefinition;

package/dist/blocks/definitions/heading.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const headingBlock: BlockDefinition;

package/dist/blocks/definitions/image.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const imageBlock: BlockDefinition;

package/dist/blocks/definitions/list.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const listBlock: BlockDefinition;

package/dist/blocks/definitions/menu.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const menuBlock: BlockDefinition;

package/dist/blocks/definitions/paragraph.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const paragraphBlock: BlockDefinition;

package/dist/blocks/definitions/socials.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const socialsBlock: BlockDefinition;

package/dist/blocks/definitions/spacer.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const spacerBlock: BlockDefinition;

package/dist/blocks/definitions/video.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const videoBlock: BlockDefinition;

package/dist/blocks/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Registers every built-in block — all 11, matching the type list confirmed
+ * against the real generators back at the start of this migration
+ * (paragraph, heading, image, video, list, button, anchor, divider,
+ * spacer, menu, socials). Idempotent — safe to call multiple times (e.g.
+ * if more than one <EmailEditor> mounts on a page), only registers once.
+ */
+export declare function registerBuiltInBlocks(): void;

package/dist/blocks/registry.d.ts

@@ -0,0 +1,23 @@
+import { BlockDefinition } from './types';
+/**
+ * Registers a block type.
+ *
+ * ```ts
+ * registerBlock({
+ *   name: "product-card",
+ *   label: "Product Card",
+ *   icon: "<svg …>",
+ *   schema: { … },
+ *   renderCanvas, renderSettings, renderEmail,
+ * });
+ * ```
+ *
+ * A two-argument form, `registerBlock(id, definition)`, is also accepted. The
+ * definition already carries `name`, so the separate id is redundant — but the
+ * built-in blocks are registered that way and external code may be too, so
+ * both keep working. When both are given, the explicit id wins.
+ */
+export declare function registerBlock(definition: BlockDefinition): void;
+export declare function registerBlock(id: string, definition: BlockDefinition): void;
+export declare function getBlock(id: string): BlockDefinition | undefined;
+export declare function getAllBlocks(): ReadonlyMap<string, BlockDefinition>;

package/dist/blocks/types.d.ts

@@ -0,0 +1,73 @@
+import { Component } from 'vue';
+/**
+ * Confirmed against the real generators (html.ts/mjml.ts/react-email.ts):
+ * each is a switch(type) dispatcher with no default case — an unmapped type
+ * renders as an empty string, silently. That's why all three export
+ * renderers are required, not optional-with-fallback.
+ *
+ * Confirmed against CanvasComponent.vue and ContentTab.vue: block dispatch
+ * actually happens in five places, not three — canvas rendering and the
+ * settings panel are separate v-if chains the original README draft didn't
+ * account for. Same "no silent gap" rule applies here for consistency:
+ * renderCanvas and renderSettings are required too.
+ */
+export interface BlockRenderContext {
+    uid: string;
+    marginStyle: string;
+    paddingStyle: string;
+    escapeHtml: (s: string) => string;
+    escapeAttr: (s: string) => string;
+    safeUrl: (s: string) => string;
+    resolveBgCss: (gradient: any, fallback: string) => string;
+    resolveBgVml: (gradient: any, fallback: string) => {
+        vmlOpen: string;
+        vmlClose: string;
+    };
+    getResponsiveClasses: (desktopHide: boolean, mobileHide: boolean, suffix?: string) => string;
+    /** React Email target only — builds JSX style objects instead of CSS
+     * strings (confirmed: hand-rolled, not the real react/mjml packages). */
+    react: {
+        parseCssString: (css: string) => Record<string, string>;
+        parseMarginPaddingDiscrete: (margin?: any, padding?: any) => Record<string, string>;
+        normalizeFontFamily: (value: string) => string;
+        styleObj: (obj: Record<string, any>) => string;
+        normalizeInlineStylesToReact: (html: string) => string;
+        buildInlineJsx: (component: "Text" | "Heading", className: string, styleRecord: Record<string, any>, children: string, as?: string) => string;
+    };
+}
+export interface BlockDefinition {
+    name: string;
+    /**
+     * Shown in the sidebar tooltip and the block's info dialog. Falls back to
+     * `name` when omitted.
+     */
+    label?: string;
+    /**
+     * Sidebar icon. Either a raw SVG string or a Vue component.
+     *
+     * A string is the common case — paste the SVG from whatever icon set you
+     * use, no import or build step. It is rendered inline so it inherits
+     * `currentColor` and the surrounding sizing, which keeps a custom block
+     * visually consistent with the built-in ones.
+     *
+     * Without an icon a registered block still works, but has no sidebar
+     * entry — it can only be added programmatically.
+     */
+    icon?: string | Component;
+    /** Drives future tooling (docs, a generic settings fallback for
+     * third-party blocks). Built-ins point renderSettings at their existing
+     * bespoke panel instead of relying on this to generate one. */
+    schema: Record<string, unknown>;
+    /** Vue component, receives a single `component` prop — the block's own
+     * node from the tree ({ id, componentType, props, ... }). Matches the
+     * existing renderer pattern (ImageRenderer, AnchorRenderer, etc). */
+    renderCanvas: Component;
+    /** Vue component, no props — reads the selected component itself via
+     * useEmailBuilder(), same as every existing panel (ButtonPanel, etc). */
+    renderSettings: Component;
+    renderEmail: {
+        html: (props: any, ctx: BlockRenderContext) => string;
+        mjml: (props: any, ctx: BlockRenderContext) => string;
+        reactEmail: (props: any, ctx: BlockRenderContext) => string;
+    };
+}

package/dist/composables/emailBuilder/components/useComponentStyleEditor.d.ts

@@ -0,0 +1,72 @@
+import { Ref, ComputedRef } from 'vue';
+export interface GradientStop {
+    color: string;
+    position: number;
+}
+export interface GradientConfig {
+    type: "linear" | "radial";
+    direction: string;
+    colors: GradientStop[];
+}
+export interface BackgroundValue {
+    useGradient: boolean;
+    solid: string;
+    gradient: GradientConfig;
+}
+export type EditMode = "desktop" | "mobile";
+export interface BorderProps {
+    width: number;
+    color: string;
+    style: "solid" | "dashed" | "dotted";
+    radius?: number;
+}
+/**
+ * Loose-but-honest shape for any component the style editor touches.
+ * Every key is optional because different component types carry different
+ * subsets (Image has no backgroundGradient, Anchor has no border, etc.).
+ *
+ * `mobile` is typed as required-but-nullable-fields because
+ * useEmailBuilderDefaults always seeds it on instantiation. Index signature
+ * preserves access to any key without enumerating every prop per component.
+ */
+export interface StyledComponentProps {
+    mobile: Record<string, any> | null;
+    border?: BorderProps;
+    backgroundColor?: string;
+    backgroundGradient?: BackgroundValue | null;
+    desktopHide?: boolean;
+    mobileHide?: boolean;
+    [key: string]: any;
+}
+export interface StyledComponent {
+    id: string;
+    type: string;
+    props: StyledComponentProps;
+}
+export declare function useComponentStyleEditor(component: Ref<StyledComponent | null> | ComputedRef<StyledComponent | null>, editMode: Ref<EditMode> | ComputedRef<EditMode>): {
+    displayValue: (key: string) => any;
+    isOverridden: (key: string) => boolean;
+    canReset: (key: string) => boolean;
+    setProp: (key: string, value: any) => void;
+    resetProp: (key: string) => void;
+    incrementProp: (key: string, step?: number) => void;
+    decrementProp: (key: string, step?: number, min?: number) => void;
+    displayBorderValue: (key: keyof BorderProps) => any;
+    setBorderProp: (key: keyof BorderProps, value: any) => void;
+    incrementBorderProp: (key: keyof BorderProps) => void;
+    decrementBorderProp: (key: keyof BorderProps) => void;
+    isBorderOverridden: () => boolean;
+    resetBorder: () => void;
+    displayBackground: () => BackgroundValue;
+    setBackground: (value: BackgroundValue) => void;
+    isBackgroundOverridden: () => boolean;
+    resetBackground: () => void;
+    toggleGradient: (useGradient: boolean) => void;
+    setGradientColors: (colors: GradientStop[]) => void;
+    setGradientConfig: (config: Partial<GradientConfig>) => void;
+    useTransparentBg: import('vue').WritableComputedRef<boolean, boolean>;
+    bgColor: ComputedRef<any>;
+    setBgColor: (value: string) => void;
+    toggleDesktopHide: () => void;
+    toggleMobileHide: () => void;
+};

package/dist/composables/emailBuilder/components/useProductRowActions.d.ts

@@ -0,0 +1,3 @@
+export declare function useProductRowActions(): {
+    saveProductRowWithToast: (row: Record<string, any>, name: string) => Promise<boolean>;
+};

package/dist/composables/emailBuilder/components/useProductRows.d.ts

@@ -0,0 +1,59 @@
+import { SavedRow, EditorStorageAdapter } from '../../../adapters/types';
+declare function createProductRowsInstance(storageAdapterInstance?: EditorStorageAdapter): {
+    productRows: import('vue').Ref<{
+        id: string;
+        name: string;
+        createdAt: string;
+        row: Record<string, any>;
+    }[], SavedRow[] | {
+        id: string;
+        name: string;
+        createdAt: string;
+        row: Record<string, any>;
+    }[]>;
+    isFetching: import('vue').Ref<boolean, boolean>;
+    fetchRows: () => Promise<void>;
+    saveProductRow: (row: Record<string, any>, name: string) => Promise<SavedRow | null>;
+    deleteProductRow: (entryId: string) => Promise<void>;
+    renameProductRow: (entryId: string, newName: string) => Promise<{
+        id: string;
+        name: string;
+        createdAt: string;
+        row: Record<string, any>;
+    }[]>;
+    cloneRowForCanvas: (entryId: string) => Record<string, any> | null;
+};
+type ProductRowsInstance = ReturnType<typeof createProductRowsInstance>;
+/** Called once, at the EmailEditor root. storageAdapterInstance is the
+ * already-created return value of provideStorageAdapter() — same reasoning
+ * as useEmailBuilder.ts's matching parameter: inject() never sees a
+ * component's own provides, so useStorageAdapter() called from anywhere
+ * within EmailEditor.vue's own setup() can never find what
+ * provideStorageAdapter() (also called there) just provided. */
+export declare function provideProductRows(storageAdapterInstance?: EditorStorageAdapter): {
+    productRows: import('vue').Ref<{
+        id: string;
+        name: string;
+        createdAt: string;
+        row: Record<string, any>;
+    }[], SavedRow[] | {
+        id: string;
+        name: string;
+        createdAt: string;
+        row: Record<string, any>;
+    }[]>;
+    isFetching: import('vue').Ref<boolean, boolean>;
+    fetchRows: () => Promise<void>;
+    saveProductRow: (row: Record<string, any>, name: string) => Promise<SavedRow | null>;
+    deleteProductRow: (entryId: string) => Promise<void>;
+    renameProductRow: (entryId: string, newName: string) => Promise<{
+        id: string;
+        name: string;
+        createdAt: string;
+        row: Record<string, any>;
+    }[]>;
+    cloneRowForCanvas: (entryId: string) => Record<string, any> | null;
+};
+/** Every other file calls this exactly as before. */
+export declare const useProductRows: () => ProductRowsInstance;
+export {};

package/dist/composables/emailBuilder/core/config/componentConfig.d.ts

@@ -0,0 +1,29 @@
+import { VisibilityOperator } from '../useEmailBuilderVisibility';
+export interface VisibilityRule {
+    tag: string;
+    operator: VisibilityOperator;
+    value: string;
+}
+export interface VisibilityGroup {
+    match: "all" | "any";
+    rules: VisibilityRule[];
+}
+export interface VisibilityConfig {
+    enabled: boolean;
+    match: "all" | "any";
+    rules: VisibilityRule[];
+    groups?: VisibilityGroup[];
+}
+export interface HideConfig {
+    desktopHide: boolean;
+    mobileHide: boolean;
+}
+export interface BaseComponentConfig extends HideConfig {
+    visibility: VisibilityConfig;
+}
+export declare const createDefaultVisibility: () => VisibilityConfig;
+export declare const createDefaultHide: () => HideConfig;
+export declare const createDefaultBaseConfig: () => BaseComponentConfig;
+export declare const DEFAULT_VISIBILITY: Readonly<VisibilityConfig>;
+export declare const DEFAULT_HIDE: Readonly<HideConfig>;
+export declare const DEFAULT_BASE_CONFIG: Readonly<BaseComponentConfig>;

package/dist/composables/emailBuilder/core/link-tags/useLinkTagInsert.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef } from 'vue';
+interface LinkComponent {
+    props: Record<string, any>;
+}
+export declare const useLinkTagInsert: (component: ComputedRef<LinkComponent | undefined>, defaultField?: string) => {
+    lastFocusedField: import('vue').Ref<string, string>;
+    trackCursor: (field: string, event: Event) => void;
+    handleTagInsert: ({ tag, default: fallback }: {
+        tag: string;
+        default?: string;
+    }, inputRefs?: Record<string, any>) => void;
+};
+export {};

package/dist/composables/emailBuilder/core/merge-tags/mergeTagDefinitions.d.ts

@@ -0,0 +1,64 @@
+/**
+ * mergeTagDefinitions.ts
+ * Shared utilities for merge tag resolution, detection, and export flattening.
+ *
+ * Used by:
+ *   - EmailBuilderCanvasComponent.vue  (preview resolution)
+ *   - LinkTagTab.vue                   (auto-detection)
+ *   - MergeTagTab.vue                  (auto-detection)
+ *   - mergeTagMapper.ts                (export transformation)
+ *   - Build / export pipeline          (flattening)
+ */
+/**
+ * Extract all unique merge tag names from a string.
+ * Safe to call on both rich-text HTML strings and plain strings.
+ */
+export declare const extractMergeTags: (text: string) => string[];
+/**
+ * Extract all unique merge tags along with their inline defaults.
+ *
+ * Returns a map of tagName → fallback (empty string when no default is
+ * specified). When the same tag appears multiple times with different
+ * defaults the first-seen default wins.
+ *
+ * Used by the export pipeline to carry fallback values through to
+ * mergeTagMapper.transformToken().
+ */
+export declare const extractMergeTagsWithDefaults: (text: string) => Map<string, string>;
+/**
+ * Resolve merge tags in a plain string using the preview context.
+ *
+ * Resolution priority (mirrors RichTextEditor.vue buildPreviewHTML):
+ *   1. Explicit value in context          → "Philip"
+ *   2. Inline default in tag syntax       → {{ name|'Friend' }} → "Friend"
+ *   3. Neither set                        → "{{ name }}" (visually unresolved)
+ *
+ * When previewActive is false the original string is returned unchanged,
+ * so callers can bind this unconditionally without a v-if guard.
+ */
+export declare const resolveString: (str: string, context: Record<string, string>, previewActive: boolean) => string;
+/**
+ * Flatten a plain string for canonical storage — normalises {{ tag }} tokens
+ * to a clean, consistent `{{ tag }}` format, stripping any accidental extras.
+ *
+ * For rich-text HTML (paragraph / heading) use flattenRichTextContent()
+ * instead — that one handles span[data-merge] nodes produced by TipTap.
+ */
+export declare const flattenPlainString: (str: string) => string;
+/**
+ * Flatten TipTap-produced HTML into the canonical {{ tag }} / {{ tag|'default' }}
+ * format for storage. Replaces every <span data-merge="name"> with {{ name }},
+ * and preserves the data-merge-default attribute as the inline default so the
+ * fallback survives the storage round-trip and reaches transformHTML() at
+ * export time.
+ *
+ * Examples:
+ *   <span data-merge="name" data-merge-default="Tony">…</span>  → {{ name|'Tony' }}
+ *   <span data-merge="name">…</span>                             → {{ name }}
+ *
+ * This is the STORAGE flattener — it produces canonical {{ }} tokens.
+ * For ESP-specific export use mergeTagMapper.transformHTML() instead.
+ *
+ * Safe to call in SSR — uses a plain regex, no DOMParser.
+ */
+export declare const flattenRichTextContent: (html: string) => string;

package/dist/composables/emailBuilder/core/merge-tags/resolveMergeTags.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Substitutes every {{ tag }} placeholder found in `source` with the
+ * corresponding value from `context`.
+ *
+ * Resolution order for each placeholder:
+ *   1. Use the context value when the tag key is present and non-empty.
+ *   2. Fall back to the pipe-default when defined: {{ tag|'Fallback' }}
+ *   3. Leave the raw placeholder as-is so it stays visible in the output.
+ *
+ * @param source   - The raw string that may contain {{ tag }} placeholders.
+ * @param context  - Key→value map built by the tab component (keys already
+ *                   normalised with `normaliseKey`).
+ * @param active   - When false the function is a no-op and returns `source`
+ *                   unchanged. Pass `mergeTagPreviewActive.value` /
+ *                   `linkTagPreviewActive.value` directly.
+ */
+export declare const resolveTags: (source: string, context: Record<string, string>, active: boolean) => string;
+/**
+ * Convenience overload that accepts the full context object and both active
+ * flags, applying merge tags first and link tags second.
+ *
+ * This ordering matters because merge tags appear inside rich-text HTML
+ * (paragraph / heading content) while link tags typically live in href
+ * attributes and anchor text — there is no semantic overlap, but doing
+ * merge → link keeps the substitution deterministic.
+ */
+export declare const resolveAllTags: (source: string, mergeContext: Record<string, string>, mergeActive: boolean, linkContext: Record<string, string>, linkActive: boolean) => string;

package/dist/composables/emailBuilder/core/ui/useLayerHoverScroll.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'vue';
+export declare function useLayerHoverScroll(layerHoveredId: Ref<string | null>, options?: {
+    canvasSelector?: string;
+    behavior?: ScrollBehavior;
+    delay?: number;
+    /**
+    * Margin (in px) from the viewport edges within which the target is
+    * considered "comfortably visible" and no scroll is needed. Default 80 px
+    * gives breathing room on both sides without being so generous that
+    * elements land right against an edge.
+    */
+    inViewMargin?: number;
+    /**
+    * If the target is more than this many pixels from the current scroll
+    * position, use instant jump instead of smooth scroll. Default 600 px
+    * covers roughly half a typical viewport — anything farther than that
+    * should teleport, not animate.
+    */
+    instantThreshold?: number;
+}): void;

package/dist/composables/emailBuilder/core/ui/useLayoutDrag.d.ts

@@ -0,0 +1,85 @@
+export type LayoutDragPayload = {
+    type: "row";
+    columns: number | number[];
+} | {
+    type: "spacer";
+} | {
+    type: "product-row";
+    entryId: string;
+}
+/** Drop a nested row inside an existing column (child insertion) */
+ | {
+    type: "nested-row";
+    columns: number | number[];
+    targetColumnId: string;
+    targetIndex: number;
+};
+type LayoutDragInstance = ReturnType<typeof createLayoutDragInstance>;
+/** Called once, at the EmailEditor root. */
+export declare function provideLayoutDrag(): {
+    isLayoutDragActive: import('vue').Ref<boolean, boolean>;
+    layoutDragPayload: import('vue').Ref<{
+        type: "row";
+        columns: number | number[];
+    } | {
+        type: "spacer";
+    } | {
+        type: "product-row";
+        entryId: string;
+    } | {
+        type: "nested-row";
+        columns: number | number[];
+        targetColumnId: string;
+        targetIndex: number;
+    } | null, LayoutDragPayload | {
+        type: "row";
+        columns: number | number[];
+    } | {
+        type: "spacer";
+    } | {
+        type: "product-row";
+        entryId: string;
+    } | {
+        type: "nested-row";
+        columns: number | number[];
+        targetColumnId: string;
+        targetIndex: number;
+    } | null>;
+    startLayoutDrag: (e: DragEvent, payload: LayoutDragPayload) => void;
+    endLayoutDrag: () => void;
+};
+/** Every other file calls this exactly as before. */
+export declare const useLayoutDrag: () => LayoutDragInstance;
+declare function createLayoutDragInstance(): {
+    isLayoutDragActive: import('vue').Ref<boolean, boolean>;
+    layoutDragPayload: import('vue').Ref<{
+        type: "row";
+        columns: number | number[];
+    } | {
+        type: "spacer";
+    } | {
+        type: "product-row";
+        entryId: string;
+    } | {
+        type: "nested-row";
+        columns: number | number[];
+        targetColumnId: string;
+        targetIndex: number;
+    } | null, LayoutDragPayload | {
+        type: "row";
+        columns: number | number[];
+    } | {
+        type: "spacer";
+    } | {
+        type: "product-row";
+        entryId: string;
+    } | {
+        type: "nested-row";
+        columns: number | number[];
+        targetColumnId: string;
+        targetIndex: number;
+    } | null>;
+    startLayoutDrag: (e: DragEvent, payload: LayoutDragPayload) => void;
+    endLayoutDrag: () => void;
+};
+export {};

package/dist/composables/emailBuilder/core/ui/useRichTextEditors.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/vue-3';
+export declare function useRichTextEditors(): {
+    registerEditor: (id: string, editor: Editor) => void;
+    unregisterEditor: (id: string) => void;
+    editorFor: (id: string | null | undefined) => Editor | undefined;
+};