pagepilot-visual-editor 1.0.2

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

@@ -0,0 +1,7 @@
+import { ToolbarPosition } from '../types';
+/**
+ * Computes the toolbar's anchored position (just above the edited block,
+ * flipped below if there's no room). A non-null `manualOffset` overrides the
+ * auto-position so the user's drag is preserved.
+ */
+export declare function useToolbarPosition(editorEl: HTMLElement | null, open: boolean, toolbarEl: HTMLElement | null, manualOffset: ToolbarPosition | null): ToolbarPosition | null;

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

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { InlineTextToolbarProps } from './types';
+/**
+ * Floating rich-text toolbar that anchors above the block being inline-edited.
+ * The toolbar is rendered via portal at document.body so it can escape the
+ * editor's overflow/transform contexts and float anywhere on screen.
+ *
+ * Each major concern is extracted into a dedicated module under this folder:
+ *   - positioning      → hooks/useToolbarPosition
+ *   - drag handle      → hooks/useToolbarDrag
+ *   - active states    → hooks/useFormatState
+ *   - all exec commands → hooks/useToolbarCommands
+ *   - speech-to-text   → hooks/useSpeechRecognition
+ *   - dialogs / popovers → ./dialogs/* and ./popovers/*
+ *   - primitives       → ./primitives/*
+ */
+export default function InlineTextToolbar({ editorEl, open }: InlineTextToolbarProps): React.JSX.Element;

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

@@ -0,0 +1,6 @@
+/**
+ * True when `target` (typically a focus event's relatedTarget) sits inside
+ * any of the inline-edit chromes. Used by blur handlers to decide whether
+ * the focus loss is "external" (commit / dismiss) or "internal" (keep open).
+ */
+export declare function isInInlineEditChrome(target: EventTarget | null): boolean;

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

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+type Props = {
+    /** Trigger aria-label (e.g. "Text color"). */
+    label: string;
+    /** Trigger icon (e.g. the "A" or fill bucket). */
+    icon: React.ReactNode;
+    /** Popover heading ("Text Color" / "Background Color"). */
+    title: string;
+    /** Label for the no-color row at the top ("Transparent" / "Use Default"). */
+    noneLabel: string;
+    /** Value passed to onPick when the no-color row is clicked. */
+    noneValue: string;
+    onPick: (color: string) => void;
+    /**
+     * Read the color currently applied at the caret, so the picker opens on the
+     * active color instead of a fixed default. Called each time the popover opens.
+     */
+    getCurrentColor?: () => string;
+};
+export declare function ColorSwatchPopover({ label, icon, title, noneLabel, noneValue, onPick, getCurrentColor }: Props): React.JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+type Props = {
+    editorEl: HTMLElement | null;
+    open: boolean;
+    /** Called after any DOM mutation so the editor can sync localDraft. */
+    onMutate: () => void;
+};
+/**
+ * Mirrors Summernote-Lite's image popover: percentage resize, original-size
+ * restore, float-left/right/clear, delete, and a live dimensions readout
+ * ("{w}x{h} (Original: {nw}x{nh})"). Anchored above whichever <img> the user
+ * clicked inside the editor; portal'd to document.body so it escapes any
+ * overflow/transform parents.
+ */
+export declare function ImagePopover({ editorEl, open, onMutate }: Props): React.ReactPortal;
+export {};

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

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+/**
+ * "…" overflow popover used when the toolbar collapses on narrow canvases.
+ * Renders whatever children the toolbar tucks behind it, wrapped in a
+ * horizontal flex so the buttons look identical to their inline placement.
+ *
+ * Flips upward when there's not enough room below the trigger — the toolbar
+ * itself can sit anywhere on the canvas, so a fixed downward popover would
+ * fall off-screen when the toolbar is positioned near the bottom.
+ */
+export declare function OverflowMenu({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;

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

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+type Props = {
+    onPick: (rows: number, cols: number) => void;
+};
+/**
+ * 8×8 hover-grid for picking table dimensions. Hover a cell to highlight the
+ * implied rows × cols and read out the size below; click commits.
+ */
+export declare function TableGridPicker({ onPick }: Props): React.JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+/**
+ * Hairline divider. Vertical by default (between toolbar groups); pass
+ * `horizontal` to separate rows inside a dropdown menu.
+ */
+export declare function Divider({ horizontal }: {
+    horizontal?: boolean;
+}): React.JSX.Element;

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

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+type DropdownProps = {
+    /** Text label (for "Normal" / "Inter" / "16"). Mutually exclusive with `icon`. */
+    label?: string;
+    /** Icon trigger (for alignment / heading / table / color buttons). */
+    icon?: React.ReactNode;
+    /** Required when `icon` is used so the trigger is accessible. */
+    ariaLabel?: string;
+    width?: number;
+    children: (close: () => void) => React.ReactNode;
+};
+/**
+ * A trigger button + portal popover. Two visual modes:
+ *   - **Label mode** (passes `label`): white select-style pill with caret.
+ *     Used by Normal / Inter / 16 etc.
+ *   - **Icon mode** (passes `icon`): transparent icon button + small caret.
+ *     Used by align / heading / table / color buttons.
+ *
+ * Children are a render-prop receiving a `close` callback so menu items can
+ * trigger an action AND dismiss the popover in one click.
+ *
+ * The popover flips to open upward when there isn't enough room below the
+ * trigger — the inline toolbar can sit anywhere on the canvas, so a fixed
+ * downward popover would overflow off-screen for low-positioned toolbars.
+ */
+export declare function Dropdown({ label, icon, ariaLabel, width, children }: DropdownProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+type HoverButtonProps = {
+    title?: string;
+    ariaLabel?: string;
+    active?: boolean;
+    /** Extra style merged on top of btnBase / btnActive. */
+    style?: React.CSSProperties;
+    /** Cursor override (the drag handle uses 'grab' / 'grabbing'). */
+    cursor?: React.CSSProperties['cursor'];
+    /** Receives the synthetic event so callers can call preventDefault etc. */
+    onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    onMouseDown?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    children: React.ReactNode;
+};
+/**
+ * A `<button>` with the toolbar's "hover wash" interaction baked in:
+ *   - `onMouseDown={stopFocusSteal}` so clicking never steals focus from the
+ *     contentEditable being edited
+ *   - default click handler calls preventDefault (callers extend via onClick)
+ *   - hover background is HOVER_TINT unless the button is `active`
+ *   - active styling merges btnActive on top of btnBase
+ *
+ * Used directly for non-icon affordances (drag handle, alignment dropdown
+ * items). `IconBtn` is the icon-only specialization.
+ */
+export declare function HoverButton({ title, ariaLabel, active, style, cursor, onClick, onMouseDown, children, }: HoverButtonProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+type IconBtnProps = {
+    title: string;
+    active?: boolean;
+    onClick: () => void;
+    onDoubleClick?: () => void;
+    children: React.ReactNode;
+    ['data-codeview-keep']?: boolean | string;
+};
+/**
+ * Generic icon-only toolbar button. Handles the active/pressed style and the
+ * hover wash, and (critically) calls preventDefault on mousedown so clicking
+ * never steals focus from the contentEditable being edited.
+ */
+export declare function IconBtn({ title, active, onClick, onDoubleClick, children, ...rest }: IconBtnProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+type MenuItemProps = {
+    /** Style overrides merged on top of menuItemStyle (e.g. a font-family preview). */
+    style?: React.CSSProperties;
+    /** Invoked on click; menu closing is the caller's responsibility (see `close`). */
+    onSelect: () => void;
+    children: React.ReactNode;
+};
+/**
+ * One row inside a Dropdown menu. Wraps the repeated pattern
+ *   <button
+ *     onMouseDown={stopFocusSteal}
+ *     onClick={(e) => { e.preventDefault(); cmd.runCommand(...); close(); }}
+ *     style={menuItemStyle}
+ *   >
+ * that block-style / heading / alignment / font menus all duplicated.
+ *
+ * Caller composes the close-on-pick behavior in `onSelect`:
+ *   <MenuItem onSelect={() => { cmd.runCommand('formatBlock', '<h1>'); close(); }} />
+ */
+export declare function MenuItem({ style, onSelect, children }: MenuItemProps): React.JSX.Element;
+type CheckedMenuItemProps = MenuItemProps & {
+    /** Renders a leading check-mark gutter; the check icon shows when `selected`. */
+    selected: boolean;
+};
+/**
+ * MenuItem variant with a leading check-mark gutter — used by the font-name
+ * and font-size dropdowns to flag the currently-applied value. The gutter
+ * keeps text aligned whether or not the row is selected.
+ */
+export declare function CheckedMenuItem({ style, selected, onSelect, children }: CheckedMenuItemProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+/**
+ * Microphone glyph for the voice-input button. Summernote-Lite's `note-icon`
+ * font ships no microphone, so we inline the same SVG that the sidebar's
+ * SpeechToTextButton uses — keeping the two editors visually identical.
+ */
+export declare function MicIcon(): React.JSX.Element;

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

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+type Props = {
+    /** The icon suffix, e.g. "bold" -> `note-icon-bold`. */
+    name: string;
+    size?: number;
+    style?: React.CSSProperties;
+};
+/**
+ * Renders one of Summernote's built-in glyphs (the same icon font the
+ * left-sidebar Text panel uses). Wrapping `<i className="note-icon-…" />`
+ * in a component so the toolbar JSX reads the same way it did with MUI
+ * icons, and so the inline styling stays consistent across every button.
+ */
+export declare function NoteIcon({ name, size, style }: Props): React.JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+/**
+ * Selection save/restore helpers.
+ *
+ * All formatting commands (execCommand and Range-based operations alike) act
+ * on whatever selection happens to be live in the DOM. When the user opens a
+ * dropdown, picks a color from a native <input type="color"> dialog, or uses
+ * the speech recognition popup, the browser can collapse the selection — so
+ * by the time our onClick runs, execCommand has nothing to act on.
+ *
+ * We mirror the last known selection *inside the editor* and restore it just
+ * before each command. preventDefault on mousedown alone isn't enough in
+ * every browser/scenario, and this is the standard belt-and-braces fix.
+ */
+export declare function isRangeInside(range: Range | null, el: HTMLElement | null): boolean;
+export declare function saveSelectionInside(el: HTMLElement | null): Range | null;
+export declare function restoreSelection(range: Range | null, el: HTMLElement | null): void;
+export declare function insertTextAtSelection(text: string): void;

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

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+export declare const iconSx: {
+    readonly fontSize: 18;
+};
+export declare const btnBase: React.CSSProperties;
+export declare const btnActive: React.CSSProperties;
+export declare const popoverStyle: React.CSSProperties;
+export declare const menuListStyle: React.CSSProperties;
+export declare const menuItemStyle: React.CSSProperties;
+/** Hover-tint applied to icon-style buttons. */
+export declare const HOVER_TINT = "rgba(15,23,42,0.06)";
+export declare const TOOLBAR_Z_INDEX = 1400;
+export declare const TOOLBAR_POPOVER_Z_INDEX = 1410;
+export declare const TOOLBAR_DIALOG_Z_INDEX = 1500;

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

@@ -0,0 +1,36 @@
+export type ToolbarPosition = {
+    top: number;
+    left: number;
+};
+export type FormatSnapshot = {
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    strike: boolean;
+    sup: boolean;
+    sub: boolean;
+    ul: boolean;
+    ol: boolean;
+    alignLeft: boolean;
+    alignCenter: boolean;
+    alignRight: boolean;
+    alignJustify: boolean;
+    blockLabel: string;
+    fontName: string;
+    fontSize: 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;
+};
+export declare const DEFAULT_FORMAT: FormatSnapshot;
+export type InlineTextToolbarProps = {
+    /** The contentEditable element the toolbar acts on. */
+    editorEl: HTMLElement | null;
+    /** Visibility — usually mirrors the inline-editing state. */
+    open: boolean;
+};
+export type LinkInsertParams = {
+    text: string;
+    url: string;
+    newWindow: boolean;
+};

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

@@ -0,0 +1,17 @@
+export type TStyle = {
+    backgroundColor?: any;
+    backgroundImage?: any;
+    backgroundSize?: any;
+    borderColor?: any;
+    borderRadius?: any;
+    color?: any;
+    textColor?: any;
+    fontFamily?: any;
+    fontSize?: any;
+    fontWeight?: any;
+    fontStyle?: any;
+    textDecoration?: any;
+    padding?: any;
+    textAlign?: any;
+    buttonTextAlign?: any;
+};

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

@@ -0,0 +1,44 @@
+import { default as React } from 'react';
+/**
+ * Utility: parse a raw block string and render it with unfilled Handlebars
+ * tokens replaced by styled React pill chips. Used by every editable block
+ * type (Heading, Text, Button, Html) so the canvas never shows raw
+ * `{{syntax}}` to the end user.
+ *
+ * Rules:
+ *   {{#each X}}...{{/each}}  →  teal "↻ X" chip  (inner body collapsed)
+ *   {{token}}                →  purple "◈ token" chip
+ *
+ * A block that has NO unfilled tokens (either because it has no `{{` at all,
+ * or because applyVariables already substituted all of them) never reaches
+ * this component — callers short-circuit before rendering.
+ */
+interface TokenSegment {
+    type: 'text' | 'var' | 'loop';
+    value: string;
+}
+/** Split raw Handlebars source into alternating text / token / loop segments. */
+export declare function parseTokenSegments(raw: string): TokenSegment[];
+/** True when the raw string contains at least one Handlebars token. */
+export declare function hasUnfilledTokens(raw: string): boolean;
+interface TokenPillsProps {
+    raw: string;
+    /** Inherit the block's text styles so chips sit inline naturally. */
+    style?: React.CSSProperties;
+    /**
+     * Called with the token id when a chip is clicked. Used to jump the user to
+     * the Variables tab so they can fill the value. When provided, chips become
+     * clickable (pointer cursor + "click to fill" tooltip).
+     */
+    onTokenClick?: (id: string) => void;
+}
+/**
+ * Renders a raw Handlebars string as React with inline pill chips for
+ * unfilled tokens. Safe to embed inside any block type — uses no innerHTML.
+ *
+ * Chips read as an actionable prompt ("✎ Add First Name") rather than a raw
+ * token, so a user who just applied a template immediately understands the
+ * slot needs a value and (when clickable) where to fill it.
+ */
+export declare function TokenPills({ raw, style, onTokenClick }: TokenPillsProps): React.JSX.Element;
+export {};

package/dist/editor-sample/documents/blocks/helpers/block-wrappers/EditorBlockWrapper.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+type TEditorBlockWrapperProps = {
+    children: React.JSX.Element;
+};
+export default function EditorBlockWrapper({ children }: TEditorBlockWrapperProps): React.JSX.Element;
+export {};

package/dist/editor-sample/documents/blocks/helpers/block-wrappers/ReaderBlockWrapper.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { TStyle } from '../TStyle';
+type TReaderBlockWrapperProps = {
+    style: TStyle;
+    children: React.JSX.Element;
+};
+export default function ReaderBlockWrapper({ style, children }: TReaderBlockWrapperProps): React.JSX.Element;
+export {};

package/dist/editor-sample/documents/blocks/helpers/block-wrappers/TuneMenu.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+type Props = {
+    blockId: string;
+};
+export default function TuneMenu({ blockId }: Props): React.JSX.Element;
+export {};

package/dist/editor-sample/documents/blocks/helpers/block-wrappers/useCanvasDrop.d.ts

@@ -0,0 +1,18 @@
+import { DropPosition } from '../documentUtils';
+/**
+ * Canvas-side counterpart to the Layers panel's drag logic (useLayerNode). Lets
+ * a tile dragged from the left BlocksPanel palette be DROPPED onto a specific
+ * on-canvas block, so the new block lands exactly under the cursor (before /
+ * after the hovered block, or inside it when it's a container) instead of always
+ * being appended to the bottom.
+ *
+ * Returns the current drop position (for rendering the indicator) plus the three
+ * drag handlers to spread onto the block wrapper. Only reacts to the palette
+ * drag MIME so it never interferes with text selection or other drags.
+ */
+export declare function useCanvasDrop(blockId: string): {
+    dropPos: DropPosition;
+    handleDragOver: (e: React.DragEvent) => void;
+    handleDragLeave: (e: React.DragEvent) => void;
+    handleDrop: (e: React.DragEvent) => void;
+};

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

@@ -0,0 +1,27 @@
+/**
+ * Block hide/unhide ("visibility") helpers.
+ *
+ * A block is hidden by setting a boolean `hidden` flag on its `data` object.
+ * `data` exists on every block type (`{ data: { props, style, ... } }`), so a
+ * single flag works uniformly for Text/Heading/Button and every container/leaf
+ * block without per-type branching.
+ *
+ * Semantics:
+ *  - Editor canvas: a hidden block is collapsed out of view (display:none) but
+ *    still appears in the Layers panel so the user can unhide it.
+ *  - Published HTML: the block is rendered with `display:none` (kept in the DOM
+ *    but not visible) — see ReaderBlock in email-builder/src/Reader/core.tsx.
+ *
+ * Hiding a container hides its whole subtree automatically: the wrapper element
+ * carrying display:none contains the descendants, so they collapse with it.
+ */
+/** Read the hidden flag off a block (defensive against undefined/null blocks). */
+export declare function isBlockHidden(block: any): boolean;
+/**
+ * Return a new block object with `data.hidden` set to `hidden`.
+ * Immutable — the original block is left untouched. When unhiding we delete the
+ * key rather than store `false` so documents stay clean and diff-friendly.
+ */
+export declare function setBlockHidden<T extends {
+    data?: any;
+}>(block: T, hidden: boolean): T;

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

@@ -0,0 +1,126 @@
+export declare const insertDocument: (documentTree: Record<string, any>, targetChildId: string, insertedChildId: string) => {
+    parentId: string;
+    updatedParent: any;
+};
+/**
+ * Walk a block subtree (the block + every nested child across all container-style
+ * props) and return the ordered list of block ids that compose it. Shared by the
+ * container-repeat engine and the template-variable row index.
+ */
+export declare function collectSubtreeIds(documentTree: Record<string, any>, rootId: string): string[];
+/**
+ * Deep-clone a subtree under fresh block ids. Returns the new blocks keyed by
+ * new id, the idMap (oldId → newId) and the new root id. Pure — caller splices.
+ */
+export declare function cloneSubtree(documentTree: Record<string, any>, rootId: string): {
+    newBlocks: Record<string, any>;
+    idMap: Record<string, string>;
+    newRootId: string;
+};
+/**
+ * Materialize one repeat row: clone the `sourceBlockId` subtree and place the
+ * clone after `afterBlockId` (the previous row's block). Returns the updated
+ * document + the new clone's root id (store it in the field's rowIds).
+ *
+ * Grid-aware: if the previous block sits in a Grid cell, the clone is dropped
+ * into the grid's NEXT EMPTY cell (so copies flow across the grid's columns/rows
+ * instead of stacking inside one cell). When every cell is already full the grid
+ * can't grow on its own — returns null so the caller can surface that.
+ */
+export declare const addRepeatRow: (documentTree: Record<string, any>, sourceBlockId: string, afterBlockId: string) => {
+    updatedDocument: Record<string, any>;
+    newRootId: string;
+} | null;
+/**
+ * Remove a set of block ids and filter them out of every parent's child-id
+ * arrays. Used to delete a repeat row's cloned container subtree.
+ */
+export declare function removeSubtree(documentTree: Record<string, any>, idsToRemove: Set<string>): Record<string, any>;
+export type DropPosition = 'before' | 'after' | 'inside';
+export declare const PALETTE_DRAG_MIME = "application/x-ahd-palette-block";
+/**
+ * Move `draggedId` relative to `targetId`:
+ *   - 'before' / 'after' → place it as a sibling of the target in the target's
+ *     parent list, just before/after the target.
+ *   - 'inside'           → append it as the last child of the target container.
+ *
+ * Returns null for invalid moves (dropping a block onto itself or into its own
+ * descendant, or a target/insert slot that can't be found).
+ */
+export declare function moveBlock(documentTree: Record<string, any>, draggedId: string, targetId: string, position: DropPosition): Record<string, any> | null;
+/**
+ * Insert a BRAND-NEW block (not an existing one) into the document relative to a
+ * drop target. Sibling of `moveBlock`, but there's no detach step — the new
+ * block is added to the flat map under `newBlockId`, then wired into a child-id
+ * list:
+ *   - 'before' / 'after' → placed as a sibling of `targetId` in its parent list.
+ *   - 'inside'           → appended as the last child of the `targetId` container.
+ *
+ * Used by the palette → canvas drop flow so a dropped tile lands exactly where
+ * the cursor was, instead of always appending to the bottom. Returns the updated
+ * document, or null when the target slot can't be found / the block can't hold
+ * children (caller can fall back to append-to-root).
+ */
+export declare function insertBlockAt(documentTree: Record<string, any>, newBlockId: string, newBlock: any, targetId: string, position: DropPosition): Record<string, any> | null;
+/** True when a block type can contain children (a valid 'inside' drop target). */
+export declare function isContainerBlock(block: any): boolean;
+/**
+ * True when a block holds its children in ONE unambiguous list (Container,
+ * ButtonGroup, EmailLayout) — so a whole-block "inside" drop has an obvious
+ * destination.
+ *
+ * Multi-slot containers (ColumnsContainer / FlexColumns / Grid / Accordion /
+ * Tabs / …) are deliberately excluded: each of their columns/cells/items renders
+ * its OWN EditorChildrenIds, which are the real drop zones. Offering a whole-block
+ * "inside" tint there is misleading (it'd silently land in slot 0) and looks like
+ * a stray highlight over the multi-column layout. For those, the outer wrapper
+ * only offers before/after; dropping into a specific slot goes through that slot.
+ */
+export declare function isSingleListContainer(block: any): boolean;
+export declare function syncStepperInSteps(steps: any[]): any[];
+export declare const duplicateBlock: (documentTree: Record<string, any>, rootId: string) => {
+    updatedDocument: Record<string, any>;
+    newRootId: string;
+};
+export declare const cloneCopiedBlocks: (copiedConfig: {
+    rootBlockId: string;
+    blocks: Record<string, any>;
+}) => {
+    newBlocks: Record<string, any>;
+    newRootId: string;
+};
+export declare const pasteBlockAsNew: (documentTree: Record<string, any>, copiedConfig: {
+    rootBlockId: string;
+    blocks: Record<string, any>;
+}) => {
+    updatedDocument: {
+        [x: string]: any;
+    };
+    newRootId: string;
+};
+export declare const pasteBlock: (documentTree: Record<string, any>, targetBlockId: string, copiedConfig: {
+    rootBlockId: string;
+    blocks: Record<string, any>;
+}) => {
+    updatedDocument: Record<string, any>;
+    newRootId: string;
+};
+/**
+ * Strip blocks whose `type` isn't in `knownTypes` from a document and unlink
+ * them from every parent's children list (root.data.childrenIds, container
+ * props.childrenIds, columns/cells, accordion/tabs/carousel/marquee items,
+ * MenuPicker start/end children). Used when pasting an external payload —
+ * the standalone editor doesn't ship every host-only block type (MenuPicker,
+ * DemoPicker, Mdx, …), so removing them gracefully lets the rest paste
+ * instead of crashing the canvas inside `BlockComponent` (which throws
+ * "Cannot read properties of undefined (reading 'Component')" the moment an
+ * unknown type tries to render).
+ *
+ * Returns the sanitized document, the de-duped list of removed type names
+ * (for a user-facing toast), and whether any pruning happened.
+ */
+export declare function sanitizeAgainstKnownTypes(doc: Record<string, any>, knownTypes: ReadonlySet<string>): {
+    sanitized: Record<string, any>;
+    removedTypes: string[];
+    changed: boolean;
+};

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

@@ -0,0 +1,33 @@
+export declare const FONT_FAMILIES: {
+    key: string;
+    label: string;
+    value: string;
+}[];
+export declare const FONT_FAMILY_NAMES: readonly ["MODERN_SANS", "BOOK_SANS", "ORGANIC_SANS", "GEOMETRIC_SANS", "HEAVY_SANS", "ROUNDED_SANS", "MODERN_SERIF", "BOOK_SERIF", "MONOSPACE", "ROBOTO", "OPEN_SANS", "LATO", "POPPINS", "INTER", "MONTSERRAT", "RALEWAY", "NUNITO", "PLAYFAIR_DISPLAY", "MERRIWEATHER", "PT_SANS", "OSWALD", "SOURCE_SANS_PRO", "RUBIK", "WORK_SANS", "NOTO_SANS", "DANCING_SCRIPT", "PACIFICO", "LOBSTER", "BEBAS_NEUE"];
+/**
+ * Maps each Google Font we expose in the picker to the weight cuts Google
+ * actually publishes for it. Single-cut display faces (Pacifico, Lobster, etc.)
+ * use [400] — Google Fonts rejects a `:wght@...` clause for them.
+ *
+ * This is the single source of truth: the editor canvas, the published page
+ * renderer, and the SPA shell all derive their `<link>` URLs from this config.
+ */
+export declare const GOOGLE_FONT_CONFIG: Record<string, number[]>;
+export declare const GOOGLE_FONTS_URL: string;
+/**
+ * Quill writes the chosen font as an inline `style="font-family: ..."` via
+ * the Style attributor, so the saved HTML is self-contained — no extra CSS
+ * needs to ship alongside the page. The toolbar picker still needs CSS to
+ * (a) render each option in its own face and (b) show a human-readable
+ * label instead of the raw CSS stack the attributor writes into data-value.
+ * Both rules live ONLY inside QuillEditor's <style>, never in the published
+ * HTML.
+ *
+ * 'inherit' is the default (no inline style) so it's excluded from the whitelist.
+ */
+export declare const QUILL_FONT_OPTIONS: {
+    label: string;
+    css: string;
+}[];
+export declare const QUILL_FONT_WHITELIST: string[];
+export declare const QUILL_FONT_CSS: string;

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

@@ -0,0 +1,13 @@
+export declare const FONT_WEIGHTS: {
+    readonly REGULAR: "400";
+    readonly MEDIUM: "500";
+    readonly SEMIBOLD: "600";
+    readonly BOLD: "700";
+};
+export type FontWeight = (typeof FONT_WEIGHTS)[keyof typeof FONT_WEIGHTS];
+export declare const FONT_WEIGHT_VALUES: [FontWeight, ...FontWeight[]];
+export declare const FONT_WEIGHT_OPTIONS: {
+    value: FontWeight;
+    label: string;
+}[];
+export declare function normalizeFontWeight(value?: string | null): FontWeight;