xiaodao-editor 0.1.1

package/dist/view/context.d.ts

@@ -0,0 +1,116 @@
+import { InjectionKey, Ref } from 'vue';
+import { Editor } from '../core/Editor';
+import { Block, BlockId } from '../core/types';
+/**
+ * Injection key for the reactive `isMobile` flag. Provided by BlockEditor so
+ * child components (TableBlock, MobileToolbar, …) can adapt their rendering
+ * for touch devices. Uses `(pointer: coarse)` matchMedia — matches iOS /
+ * iPadOS / Android browsers.
+ */
+export declare const mobileKey: InjectionKey<Ref<boolean>>;
+/**
+ * A bag of props + event handlers that fully describes what the
+ * MobileToolbar should render inside its embedded HoverToolbar. Produced by
+ * whichever context currently owns the selection (text-block selection in
+ * BlockEditor, or table cell / cell-edit selection in TableBlock) and
+ * consumed by MobileToolbar which spreads it onto `<HoverToolbar mobile>`.
+ *
+ * This is the reuse mechanism: instead of duplicating HoverToolbar's buttons
+ * and logic, the source context builds the exact same prop/handler bag it
+ * would normally pass to a floating HoverToolbar, and hands it to the
+ * MobileToolbar via the bridge so a SINGLE HoverToolbar instance (in mobile
+ * mode) renders the buttons.
+ */
+export interface MobileToolbarDescriptor {
+    visible: boolean;
+    selectionRect: DOMRect | null;
+    blockId: BlockId | null;
+    blockType: string | null;
+    blockAttrs: Readonly<Record<string, unknown>>;
+    rootEl: HTMLElement | null;
+    tableMode?: boolean;
+    cellEditMode?: boolean;
+    tableActiveMarks?: Set<string>;
+    tableActiveColor?: string;
+    tableActiveBgColor?: string;
+    tableActiveVerticalAlign?: string;
+    showDelete?: boolean;
+    deleteLabel?: string;
+    deleteIcon?: string;
+    showMerge?: boolean;
+    showSplit?: boolean;
+    showHeaderRow?: boolean;
+    headerRowActive?: boolean;
+    onClose?: () => void;
+    onLinkClick?: (blockId: BlockId, from: number, to: number) => void;
+    onDelete?: () => void;
+    onMerge?: () => void;
+    onSplit?: () => void;
+    onTableHeaderRow?: () => void;
+    onTableType?: (cellType: string) => void;
+    onTableAlign?: (align: string) => void;
+    onTableVerticalAlign?: (verticalAlign: string) => void;
+    onTableMark?: (markType: string) => void;
+    onTableTextColor?: (color: string | null) => void;
+    onTableBgColor?: (color: string | null) => void;
+    onTableCopy?: () => void;
+}
+/**
+ * Injection key for the mobile-toolbar bridge — a reactive ref holding the
+ * **table-sourced** descriptor (or null). BlockEditor provides it; TableBlock
+ * injects it and publishes its toolbar state when running on a mobile device.
+ * The text-block descriptor is computed directly inside MobileToolbar from
+ * BlockEditor's hoverToolbar state (no bridge needed for that path).
+ */
+export declare const mobileToolbarBridgeKey: InjectionKey<Ref<MobileToolbarDescriptor | null>>;
+export declare const editorKey: InjectionKey<Editor>;
+/**
+ * Injection key for the reactive `editable` flag. Provided by BlockEditor
+ * so child components (BlockContent, TableBlock, …) can reactively bind
+ * `contenteditable` and gate editing actions. Unlike `editorKey` (which is
+ * non-reactive), this is a Vue `Ref<boolean>` so changes propagate
+ * immediately through the component tree.
+ */
+export declare const editableKey: InjectionKey<Ref<boolean>>;
+/**
+ * Injection key for image upload helper function. Provided by BlockEditor
+ * so child components (slash menu, image block, block-list drop handler)
+ * can initiate an image upload against the correct upload target block,
+ * with proper transient state management and document updating.
+ *
+ * The callback returns the BlockId of the NEW (or existing) image block so
+ * the caller can set focus / selection if needed.
+ */
+export type BeginImageUploadFn = (fileOrSrc: File | string, opts?: {
+    /** If provided, insert image block relative to this block id. */
+    relativeToBlockId?: BlockId | null;
+    /** 'after' (default) | 'before' | 'replace' the target block. */
+    position?: 'after' | 'before' | 'replace';
+    /** If provided and the target block is empty, convert it instead of inserting. */
+    convertIfEmpty?: boolean;
+}) => Promise<BlockId | null>;
+export declare const imageUploadKey: InjectionKey<BeginImageUploadFn>;
+/**
+ * A flat render item: the block id plus the block snapshot. The id is
+ * redundant with `block.id` but is carried separately so `BlockList` can
+ * use it as a `:key` without reaching into the block object.
+ */
+export interface BlockRenderItem {
+    readonly id: BlockId;
+    readonly block: Block;
+}
+/**
+ * Access the editor instance. Must be called within a component tree that
+ * contains a `<BlockEditor>`.
+ */
+export declare function useEditor(): Editor;
+/**
+ * Access the image upload starter helper. Returns `null` if not provided.
+ */
+export declare function useBeginImageUpload(): BeginImageUploadFn | null;
+/**
+ * Access the reactive `editable` flag. Returns a ref that is `true` when
+ * the editor is in editing mode, `false` when read-only. Must be called
+ * within a component tree that contains a `<BlockEditor>`.
+ */
+export declare function useEditable(): Ref<boolean>;

package/dist/view/domSelection.d.ts

@@ -0,0 +1,65 @@
+import { BlockId, Selection, DocState } from '../core/types';
+/**
+ * Find the contenteditable element for a block id within the editor root.
+ *
+ * The `data-block-id` attr appears BOTH on the outer `.block-host` wrapper AND
+ * on the inner contenteditable (BlockContent), so a plain querySelector returns
+ * the wrapper first. We must prefer the contenteditable editing element:
+ * focusing/placing the caret in the wrapper (a non-editable div) silences the
+ * blinking caret for EMPTY blocks (no text node to walk to). Non-text blocks
+ * (image/table/divider/TOC) have no inner contenteditable, so we fall back to
+ * the host wrapper for hit-testing / scroll-into-view.
+ */
+export declare function findBlockEl(root: HTMLElement, id: BlockId): HTMLElement | null;
+/**
+ * Read the native selection and convert it to an editor `Selection`.
+ * Returns `null` if the selection is not within a block element inside `root`.
+ */
+export declare function readDomSelection(root: HTMLElement, doc: DocState): Selection | null;
+/** Walk up from a node to find the nearest element with `data-block-id`. */
+export declare function findBlockAncestor(node: Node, root: HTMLElement): HTMLElement | null;
+/**
+ * Create a DOM Range covering [startOffset, endOffset) within a block's
+ * contenteditable element. Used for hit-testing and overlay rendering.
+ */
+export declare function rangeFromOffsets(el: HTMLElement, startOffset: number, endOffset: number): Range | null;
+export interface HitTestResult {
+    blockEl: HTMLElement;
+    blockId: BlockId;
+    offset: number;
+}
+/**
+ * Hit-test a viewport coordinate against the editor's block content elements.
+ * Returns the block id + character offset under the point, or null if the
+ * point is not over a block's contenteditable inside `root`.
+ */
+export declare function positionFromPoint(x: number, y: number, root: HTMLElement, doc: DocState): HitTestResult | null;
+/**
+ * Apply an editor selection to the DOM. Focuses the target block's
+ * contenteditable and places the caret. For Phase 1, only caret and
+ * single-block text selections are handled.
+ *
+ * Cross-block text selections are NOT applied to the native Selection (the
+ * browser cannot represent a selection spanning multiple contenteditable
+ * elements). The view layer renders them via an overlay instead.
+ */
+export declare function applySelectionToDom(root: HTMLElement, selection: Selection): void;
+/**
+ * Whether a text selection spans more than one block (and thus requires the
+ * overlay renderer instead of the native Selection API).
+ */
+export declare function isCrossBlockText(sel: Selection): boolean;
+/**
+ * Compute the viewport-space rectangles covering the visible characters in a
+ * cross-block text selection. Used by the overlay renderer.
+ *
+ * The selection is split into three regions:
+ *   - start block: [start.offset, endOfBlock)
+ *   - fully-covered middle blocks: [0, endOfBlock)
+ *   - end block: [0, end.offset)
+ * When start === end block (single-block text selection handled by the native
+ * Selection API), this returns an empty array.
+ */
+export declare function crossBlockSelectionRects(root: HTMLElement, doc: DocState, sel: Extract<Selection, {
+    kind: 'text';
+}>): DOMRect[];

package/dist/view/imageUpload.d.ts

@@ -0,0 +1,130 @@
+import { BlockId } from '../core/types';
+export type UploadStatus = 'pending' | 'success' | 'error';
+export interface UploadState {
+    readonly status: UploadStatus;
+    /** 0–1 (0%–100%), meaningful only when status==='pending'. */
+    readonly progress: number;
+    /** Error message, meaningful only when status==='error'. */
+    readonly error?: string;
+    /** Original file so retry can re-upload it. */
+    readonly file?: File;
+    /** Temporary preview URL (object URL for local preview only).
+     *  NOT saved to the document. */
+    readonly tempPreviewUrl?: string;
+    /** Block attributes to apply on success (width/height detected from file). */
+    readonly pendingAttrs?: {
+        width?: number;
+        height?: number;
+    };
+    /** AbortController for the in-flight upload. Aborted when the block is
+     *  removed or the editor is unmounted. */
+    readonly controller?: AbortController;
+}
+/** UploadResult: the final outcome handed back from the upload handler (either
+ *  external uploadImage prop or internal mockUpload). */
+export interface UploadResult {
+    readonly url: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly alt?: string;
+    readonly title?: string;
+    /** Optional server-managed file identifier (integer). When provided,
+     *  the editor tracks references and emits `cleanup:image-file` when
+     *  the last block referencing this fileId is removed. */
+    readonly fileId?: number;
+}
+/**
+ * The public-facing result type returned by the `uploadImage` prop function.
+ * Identical to UploadResult but exported under a separate name so consumers
+ * have a clean public API type.
+ */
+export interface ImageUploadResult {
+    readonly url: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly alt?: string;
+    readonly title?: string;
+    /** Optional server-managed file identifier (integer). When provided,
+     *  the editor tracks references and emits `cleanup:image-file` when
+     *  the last block referencing this fileId is removed. */
+    readonly fileId?: number;
+}
+/**
+ * The `uploadImage` prop function signature. When provided, the editor delegates
+ * image uploads to this function instead of using the built-in mock upload.
+ *
+ * The function receives:
+ *   - name:      the original file name (file.name)
+ *   - file:      the File object to upload
+ *   - controller: AbortController — the editor will call .abort() if the
+ *                 image block is removed or the editor is unmounted
+ *   - onProgress:  callback to report progress as 0–100
+ *
+ * The function must return a Promise that resolves with the final uploaded
+ * URL (and optional dimensions/metadata) or rejects with an error.
+ */
+export type UploadImageHandler = (name: string, file: File, controller: AbortController, onProgress: (percent: number) => void) => Promise<ImageUploadResult>;
+/** Convenience alias: UploadProgress = pct 0-1 callback. */
+export type UploadProgress = (progress01: number) => void;
+type StateChangeListener = (blockId: BlockId, state: UploadState | null) => void;
+export declare function getUploadState(blockId: BlockId): UploadState | null;
+export declare function setUploadState(blockId: BlockId, state: UploadState | null): void;
+export declare function subscribeUploadState(fn: StateChangeListener): () => void;
+/** Alias for subscribeUploadState (used by BlockEditor). */
+export declare const subscribeToUploadChanges: typeof subscribeUploadState;
+/** Release any object URLs and wipe the transient map.
+ *  Called by BlockEditor on destroy / document replacement. */
+export declare function resetAllUploadStates(): void;
+/** Alias for resetAllUploadStates. */
+export declare const clearAllUploadStates: typeof resetAllUploadStates;
+export declare function revokeAllTempUrls(): void;
+/** Wrap URL.createObjectURL and track in tempUrls so revokeAllTempUrls can
+ *  release everything in one shot. */
+export declare function createTempObjectUrl(file: Blob): string;
+/** Clean up upload state for a set of removed blocks.
+ *  Called by BlockEditor's document-change subscription. */
+export declare function cleanupRemovedBlockIds(removed: Iterable<BlockId>): void;
+/** Alias for cleanupRemovedBlockIds. */
+export declare function cleanupUploadState(removed: Iterable<BlockId>): void;
+export type UploadProgressFn = (progress01: number) => void;
+export interface UploadCallbacks {
+    readonly onProgress: UploadProgressFn;
+    readonly onSuccess: (result: UploadResult) => void;
+    readonly onError: (message: string) => void;
+}
+export type UploadRequestHandler = (name: string, file: File, controller: AbortController, callbacks: UploadCallbacks) => void;
+export declare function registerUploadRequestHandler(handler: UploadRequestHandler | null): void;
+/** Alias used by BlockEditor.vue (shorter name). */
+export declare const registerUploadHandler: typeof registerUploadRequestHandler;
+export declare function hasUploadRequestHandler(): boolean;
+export declare function dispatchUploadRequest(name: string, file: File, controller: AbortController, callbacks: UploadCallbacks): void;
+type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/**
+ * Simulate an upload for demo / dev environments where no real server is
+ * configured. Produces a blob: object URL in ~600 ms with fake progress.
+ *
+ * IMPORTANT: blob: object URLs are NOT serialisable across page reloads.
+ * Consumers that intend to persist and reload documents MUST provide an
+ * `uploadImage` prop. This mock exists purely so the editor still works
+ * out of the box in demos and tests.
+ */
+export declare function mockUpload(file: File, onProgress?: (progress01: number) => void): Promise<UploadResult>;
+export declare function beginUpload(blockId: BlockId, file: File): Promise<Result<UploadResult, string>>;
+/**
+ * Convert an image src string (from an <img> tag in pasted HTML) to a File
+ * object suitable for the upload pipeline.
+ *
+ * - `data:image/...;base64,...` → decode base64 → Blob → File
+ * - `blob:...`                  → fetch blob → File
+ * - `http://` / `https://`      → fetch (may fail due to CORS) → File
+ *
+ * Returns null if the conversion fails (e.g. CORS, invalid data, network).
+ */
+export declare function srcToFile(src: string, fallbackName?: string): Promise<File | null>;
+export {};

package/dist/view/inlineDom.d.ts

@@ -0,0 +1,23 @@
+import { InlineSeq } from '../core/types';
+/** CSS selector that matches any mark-carrying element. */
+export declare const MARK_SELECTOR = "b,strong,i,em,u,s,strike,del,code,a[href],span.be-color-gray,span.be-color-brown,span.be-color-orange,span.be-color-yellow,span.be-color-green,span.be-color-blue,span.be-color-purple,span.be-color-pink,span.be-color-red,span.be-bg-gray,span.be-bg-brown,span.be-bg-orange,span.be-bg-yellow,span.be-bg-green,span.be-bg-blue,span.be-bg-purple,span.be-bg-pink,span.be-bg-red";
+/** True if the sequence contains at least one text run with marks. */
+export declare function hasMarks(seq: InlineSeq): boolean;
+/**
+ * Convert an InlineSeq to an HTML string suitable for `innerHTML`.
+ * Marks are wrapped in nested tags; the order is deterministic so that
+ * repeated renders produce identical HTML (important for diffing).
+ */
+export declare function inlineToHtml(seq: InlineSeq): string;
+/**
+ * Extract an InlineSeq from the live DOM of a contenteditable element.
+ * Walks the tree, accumulating text and collecting marks from ancestor tags.
+ * Adjacent runs with identical marks are merged.
+ */
+export declare function inlineFromDom(el: HTMLElement): InlineSeq;
+/**
+ * Compute a deterministic signature string for an InlineSeq that captures
+ * both text and marks (including mark attrs). Used to decide whether a DOM
+ * re-render is needed (plain `textContent` comparison misses mark-only changes).
+ */
+export declare function contentSignature(seq: InlineSeq): string;

package/dist/view/keymapHandler.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from '../core/Editor';
+/**
+ * Resolve a keyboard event to a command and dispatch it.
+ * Returns `true` if a binding matched and the command returned `true`
+ * (handled). The caller should `preventDefault()` in that case.
+ */
+export declare function dispatchKeymap(editor: Editor, event: KeyboardEvent): boolean;

package/dist/view/ui/BlockHandle.vue.d.ts

@@ -0,0 +1,33 @@
+import { BlockId } from '../../core/types';
+/** Called by the parent (BlockEditor) when the drag actually starts (past
+ *  the threshold). We mark `dragging = true` so the .handle-grip shows the
+ *  "grabbing" cursor and the block handle keeps pointer-events auto even
+ *  if visible gets toggled. */
+declare function handleSetLocalDragging(active: boolean): void;
+declare const _default: import('vue').DefineComponent<{
+    blockId: BlockId;
+    visible: boolean;
+}, {
+    isOpen: import('vue').Ref<boolean, boolean>;
+    insertBtn: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    gripBtn: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    setLocalDragging: typeof handleSetLocalDragging;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    openPlusMenu: (anchor: HTMLElement) => any;
+    openSettingsMenu: (anchor: HTMLElement) => any;
+    gripPointerDown: (blockId: BlockId, startX: number, startY: number, options: {
+        thresholdPx: number;
+    }) => any;
+    gripPointerUp: (blockId: BlockId) => any;
+}, string, import('vue').PublicProps, Readonly<{
+    blockId: BlockId;
+    visible: boolean;
+}> & Readonly<{
+    onOpenPlusMenu?: ((anchor: HTMLElement) => any) | undefined;
+    onOpenSettingsMenu?: ((anchor: HTMLElement) => any) | undefined;
+    onGripPointerDown?: ((blockId: BlockId, startX: number, startY: number, options: {
+        thresholdPx: number;
+    }) => any) | undefined;
+    onGripPointerUp?: ((blockId: BlockId) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/view/ui/BlockSettingsMenu.vue.d.ts

@@ -0,0 +1,32 @@
+import { BlockId } from '../../core/types';
+export interface SettingsItem {
+    readonly id: string;
+    readonly icon?: string;
+    readonly iconHtml?: string;
+    readonly title?: string;
+    readonly shortcut?: string;
+    readonly shortcutHtml?: string;
+    readonly danger?: boolean;
+    readonly run: () => void;
+    readonly value?: string;
+    readonly kind?: 'turnInto' | 'align' | 'color' | 'action';
+}
+declare function onKeyDown(event: KeyboardEvent): boolean;
+declare const _default: import('vue').DefineComponent<{
+    visible: boolean;
+    anchorEl: HTMLElement | null;
+    blockId: BlockId | null;
+    rootEl: HTMLElement | null;
+}, {
+    onKeyDown: typeof onKeyDown;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+}, string, import('vue').PublicProps, Readonly<{
+    visible: boolean;
+    anchorEl: HTMLElement | null;
+    blockId: BlockId | null;
+    rootEl: HTMLElement | null;
+}> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/view/ui/CodeLangPicker.vue.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import('vue').DefineComponent<{
+    visible: boolean;
+    initialValue: string;
+    /** Anchor element (e.g. the code-block language label). */
+    anchor: HTMLElement | null;
+    rootEl: HTMLElement | null;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    confirm: (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<{
+    visible: boolean;
+    initialValue: string;
+    /** Anchor element (e.g. the code-block language label). */
+    anchor: HTMLElement | null;
+    rootEl: HTMLElement | null;
+}> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onConfirm?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/view/ui/HoverToolbar.vue.d.ts

@@ -0,0 +1,81 @@
+import { BlockId } from '../../core/types';
+export interface ToolbarButton {
+    readonly id: string;
+    readonly icon: string;
+    readonly title: string;
+    readonly active?: boolean;
+    readonly convertType?: string;
+    readonly convertAttrs?: Readonly<Record<string, unknown>>;
+}
+declare const _default: import('vue').DefineComponent<{
+    visible: boolean;
+    selectionRect: DOMRect | null;
+    blockId: BlockId | null;
+    blockType: string | null;
+    blockAttrs: Readonly<Record<string, unknown>>;
+    rootEl: HTMLElement | null;
+    tableMode?: boolean;
+    showDelete?: boolean;
+    deleteLabel?: string;
+    deleteIcon?: string;
+    showMerge?: boolean;
+    showSplit?: boolean;
+    showHeaderRow?: boolean;
+    headerRowActive?: boolean;
+    cellEditMode?: boolean;
+    tableActiveMarks?: Set<string>;
+    tableActiveColor?: string;
+    tableActiveBgColor?: string;
+    tableActiveVerticalAlign?: string;
+    mobile?: boolean;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    delete: () => any;
+    close: () => any;
+    linkClick: (blockId: BlockId, from: number, to: number) => any;
+    split: () => any;
+    merge: () => any;
+    tableHeaderRow: () => any;
+    tableType: (cellType: string) => any;
+    tableAlign: (align: string) => any;
+    tableVerticalAlign: (verticalAlign: string) => any;
+    tableMark: (markType: string) => any;
+    tableTextColor: (color: string | null) => any;
+    tableBgColor: (color: string | null) => any;
+    tableCopy: () => any;
+}, string, import('vue').PublicProps, Readonly<{
+    visible: boolean;
+    selectionRect: DOMRect | null;
+    blockId: BlockId | null;
+    blockType: string | null;
+    blockAttrs: Readonly<Record<string, unknown>>;
+    rootEl: HTMLElement | null;
+    tableMode?: boolean;
+    showDelete?: boolean;
+    deleteLabel?: string;
+    deleteIcon?: string;
+    showMerge?: boolean;
+    showSplit?: boolean;
+    showHeaderRow?: boolean;
+    headerRowActive?: boolean;
+    cellEditMode?: boolean;
+    tableActiveMarks?: Set<string>;
+    tableActiveColor?: string;
+    tableActiveBgColor?: string;
+    tableActiveVerticalAlign?: string;
+    mobile?: boolean;
+}> & Readonly<{
+    onDelete?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onLinkClick?: ((blockId: BlockId, from: number, to: number) => any) | undefined;
+    onSplit?: (() => any) | undefined;
+    onMerge?: (() => any) | undefined;
+    onTableHeaderRow?: (() => any) | undefined;
+    onTableType?: ((cellType: string) => any) | undefined;
+    onTableAlign?: ((align: string) => any) | undefined;
+    onTableVerticalAlign?: ((verticalAlign: string) => any) | undefined;
+    onTableMark?: ((markType: string) => any) | undefined;
+    onTableTextColor?: ((color: string | null) => any) | undefined;
+    onTableBgColor?: ((color: string | null) => any) | undefined;
+    onTableCopy?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/view/ui/LinkPopover.vue.d.ts

@@ -0,0 +1,62 @@
+import { BlockId } from '../../core/types';
+type PopoverMode = 'view' | 'edit';
+declare function onSave(): void;
+declare function onCancelEdit(): void;
+declare const _default: import('vue').DefineComponent<{
+    visible: boolean;
+    /** Viewport-relative rect of the link text (for positioning). */
+    anchorRect: DOMRect | null;
+    /** The block containing the link. */
+    blockId: BlockId | null;
+    /** Character offset where the link starts. */
+    from: number;
+    /** Character offset where the link ends. */
+    to: number;
+    /** Current href (empty if creating a new link). */
+    href: string;
+    /** Current link text (empty if creating a new link). */
+    text: string;
+    /** Whether to open in edit mode immediately (e.g. when creating a new link). */
+    initialMode?: PopoverMode;
+    /** Whether to show the text input field (hide when editing from Ctrl+K on selection). */
+    showTextInput?: boolean;
+    /** When provided, overrides the default editor.commands.setLink for cell edit mode. */
+    onSaveLink?: (url: string, text: string | undefined) => void;
+    /** When provided, overrides the default editor.commands.unsetLink for cell edit mode. */
+    onRemoveLinkMark?: () => void;
+    /** Read-only mode: hides the edit/delete buttons and forbids entering edit mode. */
+    readonly?: boolean;
+}, {
+    isEditing: () => boolean;
+    save: typeof onSave;
+    cancel: typeof onCancelEdit;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+}, string, import('vue').PublicProps, Readonly<{
+    visible: boolean;
+    /** Viewport-relative rect of the link text (for positioning). */
+    anchorRect: DOMRect | null;
+    /** The block containing the link. */
+    blockId: BlockId | null;
+    /** Character offset where the link starts. */
+    from: number;
+    /** Character offset where the link ends. */
+    to: number;
+    /** Current href (empty if creating a new link). */
+    href: string;
+    /** Current link text (empty if creating a new link). */
+    text: string;
+    /** Whether to open in edit mode immediately (e.g. when creating a new link). */
+    initialMode?: PopoverMode;
+    /** Whether to show the text input field (hide when editing from Ctrl+K on selection). */
+    showTextInput?: boolean;
+    /** When provided, overrides the default editor.commands.setLink for cell edit mode. */
+    onSaveLink?: (url: string, text: string | undefined) => void;
+    /** When provided, overrides the default editor.commands.unsetLink for cell edit mode. */
+    onRemoveLinkMark?: () => void;
+    /** Read-only mode: hides the edit/delete buttons and forbids entering edit mode. */
+    readonly?: boolean;
+}> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/view/ui/MobileToolbar.vue.d.ts

@@ -0,0 +1,29 @@
+import { BlockId } from '../../core/types';
+declare const _default: import('vue').DefineComponent<{
+    rootEl: HTMLElement | null;
+    focusBlockId: BlockId | null;
+    hoverVisible: boolean;
+    hoverSelectionRect: DOMRect | null;
+    hoverBlockId: BlockId | null;
+    hoverBlockType: string | null;
+    hoverBlockAttrs: Readonly<Record<string, unknown>>;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    linkClick: (blockId: BlockId, from: number, to: number) => any;
+    openPlusMenu: (blockId: BlockId, anchor: HTMLElement) => any;
+    openSettingsMenu: (blockId: BlockId, anchor: HTMLElement) => any;
+    hoverClose: () => any;
+}, string, import('vue').PublicProps, Readonly<{
+    rootEl: HTMLElement | null;
+    focusBlockId: BlockId | null;
+    hoverVisible: boolean;
+    hoverSelectionRect: DOMRect | null;
+    hoverBlockId: BlockId | null;
+    hoverBlockType: string | null;
+    hoverBlockAttrs: Readonly<Record<string, unknown>>;
+}> & Readonly<{
+    onLinkClick?: ((blockId: BlockId, from: number, to: number) => any) | undefined;
+    onOpenPlusMenu?: ((blockId: BlockId, anchor: HTMLElement) => any) | undefined;
+    onOpenSettingsMenu?: ((blockId: BlockId, anchor: HTMLElement) => any) | undefined;
+    onHoverClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/view/ui/NumberPicker.vue.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import('vue').DefineComponent<{
+    visible: boolean;
+    initialValue: number;
+    /** Anchor element (e.g. the OrderedListMenu item). */
+    anchor: HTMLElement | null;
+    rootEl: HTMLElement | null;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    confirm: (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<{
+    visible: boolean;
+    initialValue: number;
+    /** Anchor element (e.g. the OrderedListMenu item). */
+    anchor: HTMLElement | null;
+    rootEl: HTMLElement | null;
+}> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onConfirm?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/view/ui/OrderedListMenu.vue.d.ts

@@ -0,0 +1,37 @@
+import { BlockId } from '../../core/types';
+declare const _default: import('vue').DefineComponent<{
+    visible: boolean;
+    blockId: BlockId | null;
+    /** The marker element that was clicked (serves as anchor). */
+    anchor: HTMLElement | null;
+    rootEl: HTMLElement | null;
+    /** True if the previous block in document order is an ordered-list item. */
+    canContinue: boolean;
+    /** True if "Start new list" is actionable (current ordinal is not 1). */
+    canStartNew: boolean;
+    /** The currently displayed ordinal of this block (for the picker default). */
+    currentNumber: number;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    continue: () => any;
+    startNew: () => any;
+    modify: (initialValue: number) => any;
+}, string, import('vue').PublicProps, Readonly<{
+    visible: boolean;
+    blockId: BlockId | null;
+    /** The marker element that was clicked (serves as anchor). */
+    anchor: HTMLElement | null;
+    rootEl: HTMLElement | null;
+    /** True if the previous block in document order is an ordered-list item. */
+    canContinue: boolean;
+    /** True if "Start new list" is actionable (current ordinal is not 1). */
+    canStartNew: boolean;
+    /** The currently displayed ordinal of this block (for the picker default). */
+    currentNumber: number;
+}> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onContinue?: (() => any) | undefined;
+    onStartNew?: (() => any) | undefined;
+    onModify?: ((initialValue: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;