@maildeno/editor 0.1.4 → 0.4.3

package/dist/init.d.ts

@@ -1,4 +1,5 @@
 import { PartialStorageAdapter } from './adapters/types';
+import { AssistantMount } from './types/assistant';
 import { ThemeOptions } from './theme';
 /**
  * The ergonomic, no-Vue-knowledge entry point. element.ts already provides
@@ -22,6 +23,67 @@ export interface InitOptions {
         subject: string;
         html: string;
     }) => Promise<void> | void;
+    /**
+     * Name shown in the desktop-only notice's "Powered by" line. Omit for the
+     * package default; pass an empty string to drop the line entirely.
+     *
+     * Unlike storageAdapter/theme/onSendTestEmail this is a plain string, so
+     * the custom element accepts it as a `brand-name` attribute too —
+     * `<maildeno-editor brand-name="Acme">` works without any JavaScript.
+     * init() still sets it as a property below, for consistency with the
+     * other options rather than out of necessity.
+     */
+    brandName?: string;
+    /**
+     * Replaces the saved-templates panel and its header button with version
+     * history. Requires an adapter implementing the version methods — see
+     * EditorStorageAdapter; the built-in localStorage adapter implements all
+     * of them, so this works with no backend.
+     *
+     * A boolean, so the custom element accepts it as a `versions` attribute
+     * too — attribute presence is truthy, matching how HTML booleans work.
+     */
+    versions?: boolean;
+    /**
+     * Called after a successful save. Its presence is what reveals the Save
+     * button — omit it for a read-only or guest editor and the button, the
+     * save-status indicator and the autosave timer all disappear.
+     *
+     * The "save" event still fires alongside, so handle.on("save", …) keeps
+     * working; this option exists because a listener attached after mount
+     * can't retroactively decide whether the button should have rendered.
+     */
+    onSave?: (payload: {
+        templateId: string | null;
+    }) => void;
+    /**
+     * Fills the editor's assistant drawer with your own UI.
+     *
+     * The editor supplies the drawer, its trigger button, open/close state,
+     * escape handling and shadow-DOM-safe positioning; `mount` receives the
+     * drawer's body element plus a small canvas API (getJson/setJson/
+     * getSelection/setSelection/onChange) and renders whatever it likes into
+     * it — React root, plain DOM, anything.
+     *
+     * Called on first open rather than at startup, and `unmount` on close, so
+     * a drawer the user never opens costs nothing.
+     *
+     * ```ts
+     * init({
+     *   container: "#editor",
+     *   assistant: {
+     *     mount(el, editor) {
+     *       el.innerHTML = "<button>Rewrite</button>";
+     *       el.querySelector("button").onclick = async () => {
+     *         const next = await myApi.rewrite(editor.getJson());
+     *         editor.setJson(next);
+     *       };
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    assistant?: AssistantMount;
     /**
      * Render inside a shadow root (default) or directly in the page.
      *
@@ -46,6 +108,14 @@ export interface EditorHandle {
     /** Vue's defineCustomElement dispatches emits as real DOM CustomEvents
      * on the host element, with the emit payload in event.detail — this is
      * just addEventListener with that unwrapping done for you. */
+    /**
+     * Additional listeners for the save event.
+     *
+     * Only ever fires when `onSave` was passed to init(): without it the editor
+     * has no Save button and never saves, so there is no event to hear. If you
+     * only want to observe saves, pass a no-op `onSave` to enable saving and do
+     * the work here.
+     */
     on(event: "save", handler: (payload: {
         templateId: string | null;
     }) => void): void;
@@ -69,14 +139,37 @@ export interface EditorHandle {
     getMjml(mode?: "prune" | "wrap"): string | null;
     getReactEmail(mode?: "prune" | "wrap"): string | null;
     getJson(): Record<string, unknown> | null;
+    /** The write side of getJson(). Accepts what getJson() returns, so
+     * setJson(getJson()) round-trips, plus the { canvas, content: { rows } }
+     * shape version APIs typically hand back.
+     *
+     * history defaults to "undoable" — one Ctrl+Z-able step, right for
+     * anything the user triggered. Pass "reset" when swapping which document
+     * is open, where undoing back into the previous document would be wrong. */
+    setJson(data: unknown, opts?: {
+        history?: "undoable" | "reset";
+    }): void;
+    /** The selected node, or null. `type` is the block type, so a host can
+     * branch on it without resolving the id against the tree itself. */
+    getSelection(): {
+        id: string;
+        type: string | null;
+    } | null;
+    /** Selects by id, or clears with null. Returns false if no node has that
+     * id. Does not touch history — selection is view state. */
+    setSelection(id: string | null): boolean;
+    /** Fires after each committed change. Returns an unsubscribe function.
+     * Keyed to history commits rather than raw mutations, so typing inside a
+     * text block produces one call, not one per keystroke. */
+    onChange(cb: () => void): () => void;
     /** Removes the element from the DOM. Vue's custom element wrapper
      * handles unmounting the internal app and cleaning up watchers/effects
      * as part of its own disconnectedCallback — not reimplemented here. */
     destroy(): void;
 }
 export declare function init(options: InitOptions): Promise<EditorHandle>;
-export { registerBlock, getBlock, getAllBlocks, } from './blocks/registry';
-export { registerESPSyntax, getRegisteredCustomESPs, } from './esp/registry';
+export { registerBlock, getBlock, getAllBlocks } from './blocks/registry';
+export { registerESPSyntax, getRegisteredCustomESPs } from './esp/registry';
 export { registerMergeTags, getRegisteredMergeTagIds, } from './merge-tags/registry';
 export { setEditorTheme, palette } from './theme';
 export { createLocalStorageAdapter } from './adapters/localStorageAdapter';

package/dist/init.js

@@ -1,5 +1,5 @@
-import { D as h, at as ref, i as createApp, rt as reactive } from "./vue.runtime.esm-bundler-CfYyFhW6.js";
-import { a as setEditorTheme, c as createLocalStorageAdapter, d as getRegisteredMergeTagIds, f as registerMergeTags, h as registerBlock, i as palette, l as getRegisteredCustomESPs, m as getBlock, n as registerMaildenoEditorElement, p as getAllBlocks, r as EmailEditor_default, s as buildShadowStyles, u as registerESPSyntax } from "./element-CWjNN0lY.js";
+import { O as h, at as reactive, i as createApp, st as ref } from "./vue.runtime.esm-bundler-BaHqghYy.js";
+import { a as setEditorTheme, c as getRegisteredCustomESPs, d as registerMergeTags, f as getAllBlocks, h as createLocalStorageAdapter, i as palette, l as registerESPSyntax, m as registerBlock, n as registerMaildenoEditorElement, p as getBlock, r as EmailEditor_default, s as buildShadowStyles, u as getRegisteredMergeTagIds } from "./element-95RHug4F.js";
 //#region src/lightDom.ts
 var stylesInjected = false;
 /**
@@ -63,7 +63,11 @@ async function init(options) {
 			storageAdapter: options.storageAdapter,
 			theme: options.theme,
 			capabilities: options.capabilities,
-			onSendTestEmail: options.onSendTestEmail
+			onSendTestEmail: options.onSendTestEmail,
+			brandName: options.brandName,
+			versions: options.versions,
+			saveHandler: options.onSave,
+			assistant: options.assistant
 		});
 		await new Promise((resolve) => setTimeout(resolve, 0));
 		const call = (name, ...args) => {
@@ -79,6 +83,12 @@ async function init(options) {
 			getMjml: (mode = "prune") => call("getMjml", mode),
 			getReactEmail: (mode = "prune") => call("getReactEmail", mode),
 			getJson: () => call("getJson"),
+			setJson: (data, opts) => {
+				call("setJson", data, opts);
+			},
+			getSelection: () => call("getSelection"),
+			setSelection: (id) => call("setSelection", id) ?? false,
+			onChange: (cb) => call("onChange", cb) ?? (() => {}),
 			destroy: () => mount.destroy()
 		};
 	}
@@ -89,6 +99,10 @@ async function init(options) {
 	if (options.theme) el.theme = options.theme;
 	if (options.capabilities) el.capabilities = options.capabilities;
 	if (options.onSendTestEmail) el.onSendTestEmail = options.onSendTestEmail;
+	if (options.brandName !== void 0) el.brandName = options.brandName;
+	if (options.versions !== void 0) el.versions = options.versions;
+	if (options.assistant) el.assistant = options.assistant;
+	if (options.onSave) el.saveHandler = options.onSave;
 	container.appendChild(el);
 	await new Promise((resolve) => setTimeout(resolve, 0));
 	const listenerWrappers = /* @__PURE__ */ new WeakMap();
@@ -121,6 +135,18 @@ async function init(options) {
 		getJson() {
 			return el.getJson ? el.getJson() : null;
 		},
+		setJson(data, opts) {
+			el.setJson?.(data, opts);
+		},
+		getSelection() {
+			return el.getSelection ? el.getSelection() : null;
+		},
+		setSelection(id) {
+			return el.setSelection ? el.setSelection(id) : false;
+		},
+		onChange(cb) {
+			return el.onChange ? el.onChange(cb) : () => {};
+		},
 		destroy() {
 			el.remove();
 		}

package/dist/theme.d.ts

@@ -3,20 +3,41 @@
  *
  * Setting variables rather than regenerating a stylesheet is what makes this
  * work in the custom-element build: the bundled shadow-root CSS is static and
- * cannot be re-emitted at runtime, but a custom property set on the host
- * cascades into the shadow tree and updates every rule reading it, live.
+ * cannot be re-emitted at runtime, but a custom property set on the editor
+ * root cascades into the whole subtree and updates every rule reading it,
+ * live.
  */
 /**
  * Every themeable token.
  *
  * Two layers, deliberately. Core tokens (`primary`, `surface`, `text`, …)
  * re-theme the whole editor coherently. Semantic tokens (`headerBg`,
- * `inputBg`, `overlayBg`, …) default to the core ones and exist for hosts
+ * `overlayBg`, `toolbarBg`, …) default to the core ones and exist for hosts
  * that want to change one surface without redefining everything else.
  *
  * Anything left out keeps its default, so a partial theme is always coherent
  * rather than half-applied — setting only `primary` cannot produce unreadable
  * text, and setting only `headerBg` cannot leave the rest inconsistent.
+ *
+ * ── Every token here is read by something ───────────────────────────────────
+ * Twenty-one used to be listed that nothing in the package consumed:
+ * `ring`, the four `input*` tokens, `primarySoft*`, `primaryBorder`,
+ * `onPrimarySoft`, `onAccentSoft`, `inverseSurfaceHover`, `borderSubtle`,
+ * `surfaceSunken`, `shadowSm`, `shadowLg`, the four `code*` tokens and the two
+ * `skeleton*` tokens. They had CSS defaults, they type-checked, they appeared
+ * in the docs — and setting any of them did nothing, because no rule ever read
+ * the variable.
+ *
+ * The `input*` four are the ones worth knowing about: inputs are styled from
+ * `surface` / `border` / `text` / `textSubtle` directly, in the scoped CSS of
+ * InputText.vue, Select.vue and DatePicker.vue. The dark palette's "a field
+ * darker than its panel reads as an input" intent was never realised. Removing
+ * them changes nothing on screen — they were already inert — but it stops the
+ * type surface promising a control the editor does not offer. Wiring them up
+ * instead is three small scoped-CSS edits, if that look is wanted.
+ *
+ * `codeBg` and friends belong to the host dashboard's own CodeBlock component,
+ * never to the editor, which renders no code panels at all.
  */
 export interface ThemeTokens {
     /** Brand/accent colour. Drives the primary button, focus rings, selection. */
@@ -27,13 +48,16 @@ export interface ThemeTokens {
     onPrimary?: string;
     /** Page background behind the canvas. */
     background?: string;
-    /** Panels, header, toolbars, popovers. */
+    /** Panels, header, toolbars, popovers — and, because inputs read it
+     *  directly, field backgrounds. */
     surface?: string;
     /** Subtle fills — inactive tabs, secondary buttons. */
     surfaceMuted?: string;
+    /** Hover fill, and the background of a disabled input. */
     surfaceHover?: string;
     text?: string;
     textMuted?: string;
+    /** Also the input placeholder colour. */
     textSubtle?: string;
     border?: string;
     borderStrong?: string;
@@ -42,9 +66,7 @@ export interface ThemeTokens {
     success?: string;
     warning?: string;
     info?: string;
-    /** Focus ring colour. Defaults to `primary`. */
-    ring?: string;
-    /** Box-shadow used by popovers and dialogs. */
+    /** Box-shadow used by popovers and dialogs. Feeds `overlayShadow`. */
     shadow?: string;
     /** Backdrop behind modal dialogs. */
     scrim?: string;
@@ -58,10 +80,6 @@ export interface ThemeTokens {
     accentBg?: string;
     accentText?: string;
     canvasBg?: string;
-    inputBg?: string;
-    inputText?: string;
-    inputBorder?: string;
-    inputPlaceholder?: string;
     /** Dialogs, toasts, dropdowns, date picker and floating toolbars. */
     overlayBg?: string;
     overlayText?: string;
@@ -83,7 +101,7 @@ export interface ThemeTokens {
     /** Same role as `selection`, one level up: row outlines, the row's
      *  floating toolbar, and "this is a row" indicators in the Layout tab
      *  and Layers panel. Separate token so components and rows can be told
-     *  apart at a glance */
+     *  apart at a glance. */
     rowSelection?: string;
     rowSelectionBg?: string;
     rowSelectionFg?: string;
@@ -112,15 +130,34 @@ export interface ThemeTokens {
     dangerBg?: string;
     dangerFg?: string;
     dangerBorder?: string;
+    /** The dark pill — primary CTA, active tab. FLIPS to a light fill in dark
+     *  mode. Use this, not `text`, for any dark-filled control: a text token
+     *  cannot invert that way without making body copy invisible. */
+    inverseSurface?: string;
+    onInverse?: string;
+    onInverseMuted?: string;
+    /** Secondary signal, distinct from `primary`. Used for AI surfaces and the
+     *  row-selection family. */
+    accent?: string;
+    accentHover?: string;
+    onAccent?: string;
+    accentSoft?: string;
+    accentBorder?: string;
 }
 export interface ThemeOptions extends ThemeTokens {
     /** Tokens applied only in light mode. */
     light?: ThemeTokens;
     /**
-     * Tokens applied only when the editor has the `dark` class.
+     * Tokens applied only when the editor is in dark mode.
      *
      * Dark mode has its own complete set of defaults, so overriding a couple of
      * tokens here is enough — you do not have to restate a whole palette.
+     *
+     * "In dark mode" means the editor root carries the `dark` class, which
+     * useColorScheme.ts puts there by mirroring the host page's own `.dark` on
+     * <html> or <body>. A host with a working theme switcher needs no wiring;
+     * one whose switcher works some other way passes `colorMode` to
+     * <EmailEditor> instead.
      */
     dark?: ThemeTokens;
     /** @deprecated Use `primary`. */
@@ -139,10 +176,24 @@ export interface ThemeOptions extends ThemeTokens {
  * });
  * ```
  *
- * @param target For the plain Vue build, omit — defaults to
- *   `document.documentElement`. For the custom-element build, pass the
- *   `<maildeno-editor>` element, so the properties cascade into its shadow
- *   tree. `handle.setTheme()` does this for you.
+ * @param target Where the tokens are declared. **This must be the editor's own
+ *   root element**, and <EmailEditor> passes it for you — the default below is
+ *   only for callers driving the CSS variables by hand, with no editor
+ *   mounted.
+ *
+ *   Why it matters: the library build runs every injected stylesheet through
+ *   scopeInjectedCss.ts, which rewrites `:root`/`:host` to `.md-editor-scope`
+ *   so the editor's CSS cannot restyle the host page. That puts the package's
+ *   default tokens *directly on the editor root div*. A custom property
+ *   declared on an element beats any value inherited from an ancestor,
+ *   whatever the specificity — so a theme written to <html> is shadowed by the
+ *   defaults and never reaches the editor at all. Writing to the same element
+ *   the defaults land on puts the two in the same cascade, where the runtime
+ *   sheet wins on source order.
+ *
+ *   This is also why theming appeared to work when running from source (the
+ *   playground aliases straight to `src` and never runs the scoper, so `:root`
+ *   stays `:root`) and silently did nothing in a consuming app.
  */
 export declare function setEditorTheme(options: ThemeOptions, target?: HTMLElement): void;
 /**

package/dist/types/assistant.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The canvas API handed to a host-supplied assistant panel.
+ *
+ * Defined once here rather than inline in each place it appears, because it
+ * shows up in three: the #assistant slot's prop, assistant.mount()'s second
+ * argument, and EditorHandle. Three structural copies would drift the first
+ * time a method is added, and the drift would be silent — a slot typed with
+ * five methods and a callback typed with four both compile fine.
+ *
+ * A read/write subset of what EmailEditor exposes, not the whole surface.
+ * An assistant needs to see the canvas, change it, and know when it moved.
+ * It has no business calling destroy() or re-theming the editor, so those
+ * are absent rather than present-and-discouraged.
+ */
+export interface EditorWriteApi {
+    /** Current template as a plain object, or null when the canvas is empty. */
+    getJson(): Record<string, unknown> | null;
+    /**
+     * Replaces the canvas. Accepts what getJson() returns.
+     *
+     * Defaults to an undoable step, which is almost always what an assistant
+     * wants: a user who dislikes a generated design presses Ctrl+Z and has
+     * their own work back. Passing "reset" throws that away, so it is for
+     * document swaps rather than edits.
+     */
+    setJson(data: unknown, opts?: {
+        history?: "undoable" | "reset";
+    }): void;
+    /** The selected block, or null. `type` is the block type ("paragraph",
+     *  "image"), which is what a "rewrite this heading" flow branches on. */
+    getSelection(): {
+        id: string;
+        type: string | null;
+    } | null;
+    /** Selects by id, or clears with null. False if no block has that id. */
+    setSelection(id: string | null): boolean;
+    /** Runs after each committed change. Returns an unsubscribe function —
+     *  call it when the panel tears down, or the callback outlives the panel
+     *  and fires against a dead component. */
+    onChange(cb: () => void): () => void;
+}
+/**
+ * How an init()/custom-element host fills the assistant drawer.
+ *
+ * Imperative rather than a component, because that path has no framework in
+ * common with the editor — a React host renders with createRoot into the
+ * element, a vanilla host sets innerHTML, and neither should need to know
+ * Vue exists.
+ */
+export interface AssistantMount {
+    /** Called on first open, with the drawer's body element. */
+    mount: (el: HTMLElement, editor: EditorWriteApi) => void;
+    /** Called on close and on editor teardown. Tear down listeners and any
+     *  framework root here; the editor only empties the element after this. */
+    unmount?: (el: HTMLElement) => void;
+}

package/dist/{vue.runtime.esm-bundler-CfYyFhW6.js → vue.runtime.esm-bundler-BaHqghYy.js}

@@ -5884,8 +5884,8 @@ function baseCreateRenderer(options, createHydrationFns) {
 		const oldLength = c1.length;
 		const newLength = c2.length;
 		const commonLength = Math.min(oldLength, newLength);
-		let i;
-		for (i = 0; i < commonLength; i++) {
+		let i = 0;
+		for (; i < commonLength; i++) {
 			const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
 			patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
 		}
@@ -9094,4 +9094,4 @@ var compile = () => {
 	if (!!(process.env.NODE_ENV !== "production")) warn("Runtime compilation is not supported in this build of Vue. Configure your bundler to alias \"vue\" to \"vue/dist/vue.esm-bundler.js\".");
 };
 //#endregion
-export { getCurrentScope as $, mergeProps as A, resolveComponent as B, defineAsyncComponent as C, h as D, guardReactiveProps as E, onUpdated as F, watchEffect as G, toHandlers as H, openBlock as I, withCtx as J, watchPostEffect as K, provide as L, onBeforeUnmount as M, onMounted as N, inject as O, onUnmounted as P, effectScope as Q, renderList as R, createVNode as S, getCurrentInstance as T, useId as U, resolveDynamicComponent as V, watch as W, withMemo as X, withDirectives as Y, customRef as Z, createBlock as _, toDisplayString as _t, defineCustomElement as a, ref as at, createStaticVNode as b, vShow as c, toRef as ct, Comment as d, triggerRef as dt, isRef as et, Fragment as f, unref as ft, createBaseVNode as g, normalizeStyle as gt, computed as h, normalizeProps as ht, createApp as i, readonly as it, nextTick as j, mergeDefaults as k, withKeys as l, toRefs as lt, cloneVNode as m, normalizeClass as mt, Transition as n, onScopeDispose as nt, vModelSelect as o, shallowReadonly as ot, Teleport as p, camelize as pt, watchSyncEffect as q, TransitionGroup as r, reactive as rt, vModelText as s, shallowRef as st, vue_runtime_esm_bundler_exports as t, markRaw as tt, withModifiers as u, toValue as ut, createCommentVNode as v, toHandlerKey as vt, defineComponent as w, createTextVNode as x, createElementBlock as y, __exportAll as yt, renderSlot as z };
+export { customRef as $, mergeDefaults as A, renderSlot as B, createVNode as C, guardReactiveProps as D, getCurrentInstance as E, onUnmounted as F, useSlots as G, resolveDynamicComponent as H, onUpdated as I, watchPostEffect as J, watch as K, openBlock as L, nextTick as M, onBeforeUnmount as N, h as O, onMounted as P, withMemo as Q, provide as R, createTextVNode as S, defineComponent as T, toHandlers as U, resolveComponent as V, useId as W, withCtx as X, watchSyncEffect as Y, withDirectives as Z, createBlock as _, normalizeProps as _t, defineCustomElement as a, reactive as at, createSlots as b, toHandlerKey as bt, vShow as c, shallowReadonly as ct, Comment as d, toRefs as dt, effectScope as et, Fragment as f, toValue as ft, createBaseVNode as g, normalizeClass as gt, computed as h, camelize as ht, createApp as i, onScopeDispose as it, mergeProps as j, inject as k, withKeys as l, shallowRef as lt, cloneVNode as m, unref as mt, Transition as n, isRef as nt, vModelSelect as o, readonly as ot, Teleport as p, triggerRef as pt, watchEffect as q, TransitionGroup as r, markRaw as rt, vModelText as s, ref as st, vue_runtime_esm_bundler_exports as t, getCurrentScope as tt, withModifiers as u, toRef as ut, createCommentVNode as v, normalizeStyle as vt, defineAsyncComponent as w, createStaticVNode as x, __exportAll as xt, createElementBlock as y, toDisplayString as yt, renderList as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maildeno/editor",
-  "version": "0.1.4",
+  "version": "0.4.3",
   "description": "An open-source, framework-agnostic email template editor. Drag-and-drop block editing, HTML/MJML/React Email/JSON export, and a pluggable ESP-conditional-logic engine with zero required backend.",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -22,6 +22,7 @@
   "files": [
     "dist",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {
@@ -29,7 +30,9 @@
     "dev:element": "vite build --config vite.config.element.ts --watch",
     "build": "vite build && vite build --config vite.config.element.ts",
     "typecheck": "vue-tsc -p tsconfig.json --noEmit && tsc -p tsconfig.node.json --noEmit",
-    "prepublishOnly": "npm run typecheck && npm run build"
+    "prepublishOnly": "npm run typecheck && npm run build",
+    "format": "prettier --write \"src/**/*.{ts,vue}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,vue}\""
   },
   "sideEffects": [
     "**/*.css"
@@ -96,4 +99,4 @@
     "vite-plugin-dts": "^5.0.3",
     "vue-tsc": "^3.3.11"
   }
-}
+}

package/dist/composables/emailBuilder/transform/pipeline/optimizeAI.d.ts

@@ -1,125 +0,0 @@
-/**
- * optimizeAI.ts
- * AI-facing counterpart to optimize.ts. Strips default/noise values from
- * rows, columns, components, and canvas before building the snapshot sent
- * to the AI model — separate pipeline so it can strip more aggressively
- * than the JSON-export pipeline without the two compromising each other.
- *
- * optimize.ts / hydrate.ts are NOT modified by this file and are unaffected.
- *
- * Two different kinds of "default" are handled differently, on purpose:
- *
- *   - STATELESS style props (margin, padding, border, letterSpacing, ...):
- *     no "user chose to remove this" meaning attached — just set vs. unset.
- *     Diffed against each component TYPE's real default via
- *     useEmailBuilderDefaults(), so this never drifts out of sync the way a
- *     hardcoded universal check (e.g. "is it all-zero") can for component
- *     types whose real default isn't zero. The AI doesn't lose anything by
- *     these being stripped: schemaBlock() in useEmailAIPrompts.ts already
- *     tells it every prop + its default, independent of what's in the
- *     snapshot. Snapshot = the diff; schema = the full menu.
- *
- *   - SELECTION-style fields (socials platforms, mobile overrides, the icon
- *     cluster): reflect a deliberate choice, not just set-vs-unset. Mirrored
- *     EXACTLY from optimize.ts's existing logic, unchanged, so this pipeline
- *     respects the same choices the export pipeline already does.
- *
- * Restoring what gets stripped here needs no new hydrate-side code: hydrate.ts's
- * hydrateComponent() already deep-merges against each type's real defaults
- * (via the same useEmailBuilderDefaults()), so it already restores anything
- * this file strips. See useEmailAISnapshot.ts's existing hydrateAIRows /
- * hydrateAIRow / hydrateAIComponent — those remain the AI hydration path,
- * unchanged.
- */
-interface VisibilityConfig {
-    enabled: boolean;
-    match: "all" | "any";
-    rules: unknown[];
-}
-interface BorderConfig {
-    width: number;
-    style: string;
-    color: string;
-    radius?: number;
-}
-interface GradientConfig {
-    useGradient: boolean;
-    solid: string;
-    gradient: {
-        type: "linear" | "radial";
-        direction: string;
-        colors: Array<{
-            color: string;
-            position: number;
-        }>;
-    };
-}
-interface Component {
-    id: string;
-    type: string;
-    componentType?: string;
-    props: Record<string, unknown>;
-}
-type CanvasChild = Component | NestedRow | RowSpacer;
-interface Column {
-    id: string;
-    width: number;
-    children?: CanvasChild[];
-    components?: Component[];
-    backgroundColor?: string;
-    backgroundGradient?: GradientConfig;
-    backgroundImage?: string;
-    backgroundSize?: string;
-    backgroundPosition?: string;
-    backgroundRepeat?: string;
-    padding?: Record<string, number>;
-    border?: BorderConfig;
-    verticalAlign?: string;
-    [key: string]: unknown;
-}
-interface NestedRow {
-    id: string;
-    type: "row";
-    name?: string;
-    columns?: Column[];
-    visibility?: VisibilityConfig;
-    border?: BorderConfig;
-    backgroundColor?: string;
-    backgroundImage?: string;
-    backgroundSize?: string;
-    backgroundPosition?: string;
-    backgroundRepeat?: string;
-    padding?: Record<string, number>;
-    backgroundGradient?: GradientConfig;
-    minHeight?: number;
-    gap?: number;
-    [key: string]: unknown;
-}
-interface RowSpacer {
-    id: string;
-    type: "row-spacer";
-    name?: string;
-    height?: number;
-    backgroundColor?: string;
-    backgroundGradient?: GradientConfig;
-    visibility?: VisibilityConfig;
-    [key: string]: unknown;
-}
-type Row = NestedRow | RowSpacer;
-interface Canvas {
-    language?: string;
-    preheaderText?: string;
-    bodyBackgroundColor?: string;
-    bodyBackgroundImage?: string;
-    bodyBackgroundSize?: string;
-    bodyBackgroundPosition?: string;
-    bodyBackgroundRepeat?: string;
-    backgroundColor?: string;
-    width?: number;
-    padding?: Record<string, number>;
-    mobileBreakpoint?: number;
-    [key: string]: unknown;
-}
-export declare const optimizeCanvasForAI: (canvas: Canvas) => Partial<Canvas>;
-export declare const optimizeRowsForAI: (rows: Row[]) => Partial<Row>[];
-export {};