pagepilot-visual-editor 1.0.2

package/dist/editor-sample/documents/blocks/PricingAccordion/PricingAccordionPropsSchema.d.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+declare const PricingAccordionItemSchema: z.ZodObject<{
+    label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cardChildrenIds: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    detailChildrenIds: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+declare const PricingAccordionPropsSchema: z.ZodObject<{
+    style: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        backgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        borderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        borderWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        borderRadius: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodObject<{
+            topLeft: z.ZodNumber;
+            topRight: z.ZodNumber;
+            bottomRight: z.ZodNumber;
+            bottomLeft: z.ZodNumber;
+        }, z.core.$strip>]>>>;
+        padding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+            top: z.ZodNumber;
+            bottom: z.ZodNumber;
+            right: z.ZodNumber;
+            left: z.ZodNumber;
+        }, z.core.$strip>>>;
+        cardGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        equalCardWidth: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        cardBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cardBorderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cardBorderWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        cardBorderRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        cardPadding: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        cardShadow: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cardTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cardFontSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        cardFontFamily: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cardFontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cardTextAlign: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            right: "right";
+            left: "left";
+            center: "center";
+        }>>>;
+        cardHoverBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cardHoverShadow: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        activeCardBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        activeCardBorderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        activeCardShadow: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        activeCardTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        arrowColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        arrowActiveColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        arrowSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        detailBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        detailBorderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        detailBorderWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        detailBorderRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        detailPadding: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        detailShadow: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        detailGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        rightCardWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        cardListWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        panelGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    props: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        items: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            cardChildrenIds: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            detailChildrenIds: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>>>;
+        defaultOpenIndex: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        accordionEnabled: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        detailPosition: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            bottom: "bottom";
+            right: "right";
+        }>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PricingAccordionProps = z.infer<typeof PricingAccordionPropsSchema>;
+export type PricingAccordionItem = z.infer<typeof PricingAccordionItemSchema>;
+export default PricingAccordionPropsSchema;

package/dist/editor-sample/documents/blocks/Rating/RatingEditor.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { RatingProps } from './RatingPropsSchema';
+export default function RatingEditor({ style, props }: RatingProps): React.JSX.Element;

package/dist/editor-sample/documents/blocks/Rating/RatingPropsSchema.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+declare const RatingPropsSchema: z.ZodObject<{
+    style: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        starColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        starEmptyColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        starSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        starGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        textColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        fontSize: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        fontFamily: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        fontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        textAlign: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            right: "right";
+            left: "left";
+            center: "center";
+        }>>>;
+        padding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+            top: z.ZodNumber;
+            bottom: z.ZodNumber;
+            right: z.ZodNumber;
+            left: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    props: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        value: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+        max: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+        showValue: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RatingProps = z.infer<typeof RatingPropsSchema>;
+export default RatingPropsSchema;

package/dist/editor-sample/documents/blocks/SkipLink/SkipLinkEditor.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { SkipLinkProps } from '../../../../email-builder-core/blocks/SkipLink/SkipLinkPropsSchema';
+export default function SkipLinkEditor(props: SkipLinkProps): React.JSX.Element;

package/dist/editor-sample/documents/blocks/SkipLink/SkipLinkPropsSchema.d.ts

@@ -0,0 +1 @@
+export { SkipLinkPropsSchema as default, type SkipLinkProps, SkipLinkDefaults, } from '../../../../email-builder-core/blocks/SkipLink/SkipLinkPropsSchema';

package/dist/editor-sample/documents/blocks/TabsBlock/TabsBlockEditor.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { TabsBlockProps } from './TabsBlockPropsSchema';
+export default function TabsBlockEditor({ style, props }: TabsBlockProps): React.JSX.Element;

package/dist/editor-sample/documents/blocks/TabsBlock/TabsBlockPropsSchema.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+declare const TabsBlockItemSchema: z.ZodObject<{
+    label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    contentChildrenIds: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+declare const TabsBlockPropsSchema: z.ZodObject<{
+    style: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        backgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        borderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        borderRadius: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodObject<{
+            topLeft: z.ZodNumber;
+            topRight: z.ZodNumber;
+            bottomRight: z.ZodNumber;
+            bottomLeft: z.ZodNumber;
+        }, z.core.$strip>]>>>;
+        padding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+            top: z.ZodNumber;
+            bottom: z.ZodNumber;
+            right: z.ZodNumber;
+            left: z.ZodNumber;
+        }, z.core.$strip>>>;
+        tabActiveColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabBgColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tabGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        contentGap: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        navBorderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        fontSize: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        activeFontSize: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        showActiveBorder: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        fontFamily: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        fontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    props: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        orientation: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            horizontal: "horizontal";
+            vertical: "vertical";
+        }>>>;
+        behavior: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            showSelectedSection: "showSelectedSection";
+            scrollToSelectedSection: "scrollToSelectedSection";
+        }>>>;
+        activeTabIndex: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        stickyNav: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        items: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            contentChildrenIds: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type TabsBlockProps = z.infer<typeof TabsBlockPropsSchema>;
+export type TabsBlockItem = z.infer<typeof TabsBlockItemSchema>;
+export default TabsBlockPropsSchema;

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/BlockButton.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+type BlockMenuButtonProps = {
+    label: string;
+    icon: React.ReactNode;
+    onClick: () => void;
+    highlighted?: boolean;
+};
+export default function BlockTypeButton({ label, icon, onClick, highlighted }: BlockMenuButtonProps): React.JSX.Element;
+export {};

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/BlockInsertAboveContext.d.ts

@@ -0,0 +1,2 @@
+import { TEditorBlock } from '../../../../editor/core';
+export declare const BlockInsertAboveContext: import('react').Context<(block: TEditorBlock) => void>;

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/BlocksMenu.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { TEditorBlock } from '../../../../editor/core';
+type BlocksMenuProps = {
+    anchorEl: HTMLElement | null;
+    setAnchorEl: (v: HTMLElement | null) => void;
+    onSelect: (block: TEditorBlock) => void;
+    onPaste?: () => void;
+};
+export default function BlocksMenu({ anchorEl, setAnchorEl, onSelect, onPaste }: BlocksMenuProps): React.JSX.Element;
+export {};

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/DividerButton.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+type Props = {
+    buttonElement: HTMLElement | null;
+    onClick: () => void;
+};
+export default function DividerButton({ buttonElement, onClick }: Props): React.ReactPortal;
+export {};

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/PlaceholderButton.d.ts

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

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/ScopePickerMenu.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+export type ScopeOption = {
+    icon: React.ReactNode;
+    label: string;
+    isPrimary?: boolean;
+    onClick: () => void;
+};
+type Props = {
+    anchorEl: HTMLElement | null;
+    options: [ScopeOption, ScopeOption];
+    onClose: () => void;
+};
+export default function ScopePickerMenu({ anchorEl, options, onClose }: Props): React.JSX.Element;
+export {};

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/brandButtonDefaults.d.ts

@@ -0,0 +1,14 @@
+type BrandButton = any;
+type BrandingConfig = any;
+type ButtonBlockData = {
+    props: Record<string, any>;
+    style: Record<string, any>;
+};
+export declare function buildButtonBlockDataFromBrand(brandButton: BrandButton | undefined, overrides?: {
+    props?: Record<string, any>;
+    style?: Record<string, any>;
+}): ButtonBlockData;
+export declare const selectBrandButtonFromSettings: (settings: {
+    branding?: Partial<BrandingConfig>;
+} | null | undefined) => BrandButton | undefined;
+export {};

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/buttons.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { TEditorBlock } from '../../../../editor/core';
+type TButtonProps = {
+    label: string;
+    icon: React.JSX.Element;
+    block: () => TEditorBlock;
+};
+export declare const useButtons: () => TButtonProps[];
+export {};

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

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { TEditorBlock } from '../../../../editor/core';
+export type ContainerNeighbor = {
+    id: string;
+    insertAt: 'start' | 'end';
+};
+type Props = {
+    placeholder?: boolean;
+    onSelect: (block: TEditorBlock) => void;
+    onPaste?: () => void;
+    containerNeighbors?: ContainerNeighbor[];
+    onInsertIntoContainer?: (block: TEditorBlock, containerId: string, insertAt: 'start' | 'end') => void;
+    insertAboveCallback?: (block: TEditorBlock) => void;
+};
+export default function AddBlockButton({ onSelect, onPaste, placeholder, containerNeighbors, onInsertIntoContainer, insertAboveCallback, }: Props): React.JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { TEditorBlock } from '../../../editor/core';
+export declare function autoStartInlineEditing(blockId: string, block: TEditorBlock): void;
+export type EditorChildrenChange = {
+    blockId: string;
+    block: TEditorBlock;
+    childrenIds: string[];
+};
+export type EditorChildrenIdsProps = {
+    childrenIds: string[] | null | undefined;
+    onChange: (val: EditorChildrenChange) => void;
+    maxChildren?: number;
+    showContainerScopePrompt?: boolean;
+    insertAboveCallback?: (block: TEditorBlock) => void;
+};
+export default function EditorChildrenIds({ childrenIds, onChange, maxChildren, showContainerScopePrompt, insertAboveCallback, }: EditorChildrenIdsProps): React.JSX.Element;

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

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export declare function EditableTextBlock(blockProps: any): React.JSX.Element;
+export declare function EditableHeadingBlock(blockProps: any): React.JSX.Element;
+export declare function EditableButtonBlock(blockProps: any): React.JSX.Element;
+export declare function EditableMdxBlock(blockProps: any): React.JSX.Element;
+export declare function EditableHtmlBlock(blockProps: any): React.JSX.Element;

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

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+type FullscreenOverlayProps = {
+    /** The original inline-edited contentEditable in the canvas. */
+    editorEl: HTMLElement | null;
+    /** The fullscreen contentEditable element, mirrored as state by the parent. */
+    fullscreenEditorEl: HTMLElement | null;
+    /** Callback ref so the parent can subscribe to the live DOM node. */
+    registerEditor: (el: HTMLDivElement | null) => void;
+};
+/**
+ * The portaled fullscreen edit surface. A separate contentEditable whose
+ * content is mirrored from `editorEl`; on input we sync back so the original
+ * block's InlineEditableOverlay picks up the change via its input listener.
+ *
+ * We don't move the original editor element here — DOM moves fight React
+ * reconciliation and broke content rendering in earlier attempts. Instead we
+ * keep two editable surfaces and bridge them by HTML copying.
+ */
+export declare function FullscreenOverlay({ editorEl, fullscreenEditorEl, registerEditor, }: FullscreenOverlayProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+export { FONT_FAMILIES } from '../fontFamily';
+/** First family name out of a CSS font-family stack — used to match the
+ *  caret's live `font-family` (which the browser reports as the resolved
+ *  first family) against the options in FONT_FAMILIES. */
+export declare const primaryFamily: (cssFontFamily: string) => string;
+export declare const FONT_SIZES: Array<{
+    label: string;
+    px: number;
+}>;
+export declare const LINE_HEIGHTS: Array<{
+    label: string;
+    value: string;
+}>;
+export declare const BLOCK_STYLES: Array<{
+    label: string;
+    tag: string;
+}>;
+export declare const BLOCK_TAG_SHORT_LABEL: Record<string, string>;
+export declare const BLOCK_LEVEL_TAGS: Set<string>;
+export declare const BLOCK_PREVIEW_STYLE: Record<string, React.CSSProperties>;
+export declare const COMPACT_THRESHOLD = 1180;

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

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+type Props = {
+    open: boolean;
+    onClose: () => void;
+    /** Called with the entered URL + alt text when the user hits Insert. */
+    onInsert: (src: string, alt?: string) => void;
+};
+/**
+ * Insert Image dialog for the inline text toolbar.
+ *
+ * Replaces the host-only MediaGalleryDialog that the editor-sample originally
+ * relied on — the standalone editor doesn't ship a media library backend,
+ * so we surface the two things a user actually needs to add an image inline:
+ * a source URL (paste from anywhere) and an alt text (accessibility).
+ *
+ * Fresh state per open — the fields don't remember what the user last
+ * inserted, so each invocation is a clean slate.
+ */
+export declare function ImageDialog({ open, onClose, onInsert }: Props): React.JSX.Element;
+export {};

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

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { LinkInsertParams } from '../types';
+type Props = {
+    open: boolean;
+    /** Pre-fill for the "Text to display" field (typically the current selection). */
+    defaultText: string;
+    /** Pre-fill for the URL field — non-empty when editing an existing <a>. */
+    defaultUrl?: string;
+    /** The existing link's target — preserved on save when editing. Fresh
+     *  links always get target="_blank" since the previous "Open in new
+     *  window" UI was removed. */
+    defaultNewWindow?: boolean;
+    /** Flip title + button label to edit mode when standing on an existing link. */
+    isEditing?: boolean;
+    onClose: () => void;
+    onInsert: (params: LinkInsertParams) => void;
+    /** Strip the link wrapper, keeping its text. Only shown when editing an
+     *  existing link (the dialog has nothing to remove on a fresh insert). */
+    onRemove?: () => void;
+};
+/** Insert Link modal — matches the sidebar's Summernote dialog. */
+export declare function LinkDialog({ open, defaultText, defaultUrl, defaultNewWindow, isEditing, onClose, onInsert, onRemove, }: Props): React.JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+type Props = {
+    open: boolean;
+    onClose: () => void;
+    onInsert: (url: string) => void;
+};
+/** Insert Video modal — supports YouTube/Vimeo/Loom/Wistia URLs or direct .mp4 links. */
+export declare function VideoDialog({ open, onClose, onInsert }: Props): React.JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+/**
+ * Walks up the DOM from `el` and returns the closest ancestor that has a
+ * scrollable overflow style. Used by the toolbar to measure the canvas width
+ * (for the overflow "…" menu) and to observe canvas resizes.
+ */
+export declare function findScrollableAncestor(el: HTMLElement | null): HTMLElement | null;

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

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+/**
+ * Every interactive element inside the floating toolbar must call this on
+ * mousedown — otherwise the browser shifts focus off the contentEditable,
+ * collapses the selection, and execCommand has nothing to act on.
+ */
+export declare const stopFocusSteal: (e: React.MouseEvent | React.PointerEvent) => void;

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

@@ -0,0 +1,19 @@
+import { FormatSnapshot } from './types';
+/** Turn raw CSS font names like "MODERN_SANS" or "open-sans" into a friendly
+ *  "Modern Sans" / "Open Sans" so the dropdown label reads naturally.
+ */
+export declare function friendlyFontLabel(font: string): string;
+/**
+ * Reads the live document state at the caret and returns the user-facing
+ * labels for the block-style / font-name / font-size dropdowns. Only fields
+ * that can be derived from the live DOM are returned — toggle states (B / I /
+ * U / etc.) come from queryCommandState and live in useFormatState.
+ *
+ * For non-collapsed selections this walks every text node the range touches
+ * and aggregates their computed font sizes / families. If they all agree we
+ * show that value; if they disagree (mixed selection) we fall back to the
+ * selection's focus endpoint — that's where the caret lands after a toolbar
+ * command, so the label reflects what was just applied even when the rest of
+ * the original selection had a different size.
+ */
+export declare function readLiveFormat(editorEl: HTMLElement | null): Partial<FormatSnapshot>;

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

@@ -0,0 +1,35 @@
+type UseCodeViewParams = {
+    enabled: boolean;
+    editorEl: HTMLElement | null;
+    fullscreen: boolean;
+    fullscreenEditorEl: HTMLElement | null;
+    /** Called when the user requests to leave code view (ESC or focus-out). */
+    onRequestExit: () => void;
+};
+type UseCodeViewResult = {
+    textareaEl: HTMLTextAreaElement | null;
+};
+/**
+ * Mounts a code-view textarea while `enabled` is true, mirroring
+ * summernote-lite's codeview module:
+ *
+ *   activate()   prettify(html(editor)) -> textarea.val
+ *                textarea.height = editor.height
+ *                editor.style.display = 'none'
+ *                textarea.focus()
+ *   deactivate() purify(textarea.val) || emptyPara -> editor.innerHTML
+ *                editor.style.display restored; editor.focus()
+ *   ESC          deactivate
+ *   blur out     deactivate AND end inline-edit session
+ *
+ * The textarea is inserted next to the currently *visible* editor (fullscreen
+ * overlay when active, original block otherwise) so toggling code view inside
+ * fullscreen doesn't hide it behind the overlay.
+ *
+ * Per-keystroke sync into the original editor is preserved so the existing
+ * commit-on-blur flow in `InlineEditableOverlay` (which reads the
+ * contentEditable's innerHTML on commit) picks up code-view edits without
+ * needing changes elsewhere.
+ */
+export declare function useCodeView({ enabled, editorEl, fullscreen, fullscreenEditorEl, onRequestExit, }: UseCodeViewParams): UseCodeViewResult;
+export {};

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

@@ -0,0 +1,18 @@
+import { ToolbarCommandsApi } from './useToolbarCommands';
+/**
+ * Format painter: capture character formatting from one selection and apply it
+ * to subsequent selections.
+ *
+ * - Click button (or call activate()): captures from the current non-collapsed
+ *   selection, enters single-shot mode. The next non-collapsed selection in
+ *   the editor receives the captured format, then painter deactivates.
+ * - Double-click button: same capture but sticky — stays active until cancel().
+ * - Esc cancels.
+ */
+export declare function useFormatPainter(editorEl: HTMLElement | null, open: boolean, cmd: ToolbarCommandsApi): {
+    active: boolean;
+    sticky: boolean;
+    onClick: () => void;
+    onDoubleClick: () => void;
+    cancel: () => void;
+};

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

@@ -0,0 +1,11 @@
+import { FormatSnapshot } from '../types';
+/**
+ * Tracks toggle states (B/I/U/etc.) via queryCommandState plus the live
+ * caret-derived labels (block tag / font name / font size) from readLiveFormat.
+ * Re-reads on every `selectionchange`, but only when the live selection is
+ * actually inside the editor (avoids the buttons lighting up from selections
+ * elsewhere on the page). Also re-reads on `input` so toolbar commands that
+ * mutate the DOM without moving the selection (e.g. font size) refresh the
+ * displayed label.
+ */
+export declare function useFormatState(open: boolean, editorEl: HTMLElement | null): FormatSnapshot;

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

@@ -0,0 +1,24 @@
+type UseFullscreenParams = {
+    /** The original inline-edited contentEditable in the canvas. */
+    editorEl: HTMLElement | null;
+};
+type UseFullscreenResult = {
+    fullscreen: boolean;
+    setFullscreen: (value: boolean) => void;
+    fullscreenEditorEl: HTMLDivElement | null;
+    setFullscreenEditorEl: (el: HTMLDivElement | null) => void;
+};
+/**
+ * Owns the fullscreen state for the inline-edit toolbar.
+ *
+ * - Mirrors `editorEl.innerHTML` into the portaled fullscreen contentEditable
+ *   on entry, then parks the caret at the end so the user picks up where
+ *   they left off.
+ * - On exit, refocuses the original editor so its `blur` fires when the user
+ *   next clicks another block — otherwise the inline-edit session never ends
+ *   and the toolbar lingers over the wrong block.
+ * - ESC anywhere exits fullscreen (captured at document level so dialogs
+ *   inside the overlay can still consume their own ESC).
+ */
+export declare function useFullscreen({ editorEl }: UseFullscreenParams): UseFullscreenResult;
+export {};

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

@@ -0,0 +1,66 @@
+import { LinkInsertParams } from '../types';
+/** 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. */
+export type SavedLinkInfo = {
+    text: string;
+    url: string;
+    newWindow: boolean;
+};
+export type ToolbarCommandsApi = {
+    /** Currently saved selection range (latest one observed inside the editor). */
+    savedRangeRef: React.MutableRefObject<Range | null>;
+    runCommand: (cmd: string, value?: string) => void;
+    /** Like `runCommand('formatBlock', '<TAG>')`, but for blockquote/pre also
+     *  writes inline styles onto the produced element so the visual treatment
+     *  ships with the stored HTML (no dependency on global CSS, works in edit
+     *  mode, canvas, and the preview iframe). */
+    applyBlockStyle: (tag: string) => void;
+    /**
+     * Like runCommand, but restores the saved selection WITHOUT focusing the
+     * editor — used by the color picker so dragging on the saturation canvas
+     * (or typing in the hex input) doesn't lose focus to the editor on every
+     * onChange tick.
+     */
+    applyColor: (cmd: string, value: string) => void;
+    applyFontSize: (px: number) => 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;
+    /** Override the background color of the <pre> code block at the caret.
+     *  Pass an empty string (or omit) to reset back to the default dark theme. */
+    applyCodeBackground: (value: string) => void;
+    insertHtml: (html: string) => void;
+    handleInsertLink: (p: LinkInsertParams) => void;
+    /** Unwrap the <a> at the current selection, keeping its text content. */
+    handleRemoveLink: () => void;
+    handleInsertImage: (src: string, alt?: string) => void;
+    handleInsertVideo: (url: string) => void;
+    handleInsertTable: (rows: number, cols: number) => void;
+    /** True when the saved selection sits inside a table cell. */
+    isInTableCell: () => boolean;
+    /** Insert a row above/below the current cell's row. */
+    handleTableInsertRow: (where: 'above' | 'below') => void;
+    /** Insert a column left/right of the current cell's column. */
+    handleTableInsertColumn: (where: 'left' | 'right') => void;
+    /** Delete the current cell's row (drops the table if it's the last row). */
+    handleTableDeleteRow: () => void;
+    /** Delete the current cell's column (drops the table if it's the last column). */
+    handleTableDeleteColumn: () => void;
+    /** Delete the whole table at the caret. */
+    handleTableDelete: () => void;
+    handleInsertCode: () => void;
+    handleInsertHorizontalRule: () => void;
+    handleSpeechResult: (text: string) => void;
+    /** Plain-text of the currently saved selection (for prefilling Link dialog). */
+    getSavedSelectionText: () => string;
+    /** Existing-link info when the selection sits inside an <a>, else null. */
+    getSavedSelectionLink: () => SavedLinkInfo | null;
+};
+/**
+ * Bundles every editor mutation behind a single API. Each command restores
+ * the saved selection before running, then refreshes the saved range so the
+ * next command lands in the right place (e.g. insertImage moves the caret
+ * past the new node).
+ */
+export declare function useToolbarCommands(editorEl: HTMLElement | null, open: boolean): ToolbarCommandsApi;

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

@@ -0,0 +1,21 @@
+import { ToolbarPosition } from '../types';
+type DragApi = {
+    /** User-dragged offset (null = follow the block automatically). */
+    manualOffset: ToolbarPosition | null;
+    /** True while the user is actively dragging the grip handle. */
+    dragging: boolean;
+    /** Reset the manual offset back to auto-anchor (the block's "just above"). */
+    reset: () => void;
+    /** Handler to wire to the drag grip's onMouseDown. */
+    handleDragStart: (ev: React.MouseEvent) => void;
+};
+/**
+ * Encapsulates the drag-handle behavior: tracks mouse delta from the
+ * mousedown anchor, clamps the resulting position to the viewport, and
+ * exposes a `manualOffset` that overrides the auto-positioner. Resets when
+ * the edited block (or open state) changes.
+ */
+export declare function useToolbarDrag(toolbarEl: HTMLElement | null, 
+/** Reset trigger — pass anything that should restart the drag tracking. */
+resetKey: unknown): DragApi;
+export {};