wendang-react 0.0.0-stage → 0.5.5

package/dist/types/bindings/yjs.d.ts

@@ -0,0 +1,3 @@
+export { COLLAB_FIELD } from '../editor/extensions';
+export type { Awareness } from 'y-protocols/awareness';
+export type { Doc as CollaborationDocument } from 'yjs';

package/dist/types/document/viewer.d.ts

@@ -0,0 +1,3 @@
+export { DocumentViewer, DocRenderer } from '../renderer/DocumentViewer';
+export type { DocumentViewerProps } from '../renderer/DocumentViewer';
+export { MindMapBlock } from '../mindmap/MindMapViewer';

package/dist/types/document.d.ts

@@ -0,0 +1,7 @@
+export { DocumentEditor } from './editor/DocumentEditor';
+export type { DocumentEditorProps, DocumentEditorHandle } from './editor/DocumentEditor';
+export { coreExtensions, COLLAB_FIELD } from './editor/extensions';
+export type { CoreExtensionOptions } from './editor/extensions';
+export * from './engine/editor/popover-placement';
+export { sameDocument } from './editor/same-document';
+export type { ProseMirrorDoc, ProseMirrorNode } from 'wendang/types';

package/dist/types/editor/BlockAffordance.d.ts

@@ -0,0 +1,47 @@
+import type { Editor } from '@tiptap/core';
+import type { BlockHoverInfo } from '../engine/editor/extensions/block-handle';
+import type { ProseMirrorNode } from 'wendang/types';
+export interface BlockMenuProps {
+    editor: Editor;
+    info: BlockHoverInfo;
+    canComment?: boolean;
+    onClose: () => void;
+    onPickFile: (kind: 'image' | 'file') => void;
+    onPickPage: () => void;
+    onPickVideo: () => void;
+    onRequestComment?: () => void;
+    onSharePage?: () => void;
+    onCopyLink?: () => void;
+    onConvertToSubpage?: (node: ProseMirrorNode) => void;
+    onSaveAsTemplate?: (node: ProseMirrorNode) => void;
+    onNotice?: (message: string) => void;
+    panelOnly?: 'format' | 'insert-below';
+}
+export declare function blockAffordanceStyle(info: BlockHoverInfo, shell: HTMLElement | null, kind: 'plus' | 'chip'): {
+    left: number;
+    top: number;
+};
+export declare function BlockPlus({ style, expanded, onClick, onMouseEnter }: {
+    info: BlockHoverInfo;
+    style: {
+        left: number;
+        top: number;
+    };
+    expanded: boolean;
+    onClick: () => void;
+    onMouseEnter?: () => void;
+}): import("react").JSX.Element;
+export declare function BlockChip({ editor, info, style, expanded, onOpen, onOpenFull, onMouseEnter, onHandleMouseDown }: {
+    editor: Editor;
+    info: BlockHoverInfo;
+    style: {
+        left: number;
+        top: number;
+    };
+    expanded: boolean;
+    onOpen: () => void;
+    onOpenFull: () => void;
+    onMouseEnter?: () => void;
+    onHandleMouseDown?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}): import("react").JSX.Element;
+export declare function BlockMenu(props: BlockMenuProps): import("react").JSX.Element;

package/dist/types/editor/CalloutView.d.ts

@@ -0,0 +1,2 @@
+import type { NodeViewRenderer } from '@tiptap/core';
+export declare const createCalloutNodeView: () => NodeViewRenderer;

package/dist/types/editor/CodeBlockView.d.ts

@@ -0,0 +1,9 @@
+import type { NodeViewRenderer } from '@tiptap/core';
+import { type ContentContext } from '../host';
+interface YwikiCodeOptions {
+    canCopy?: () => boolean;
+    contentContext?: () => ContentContext;
+}
+export declare const createCodeBlockNodeView: (canCopy?: () => boolean, contentContext?: () => ContentContext) => NodeViewRenderer;
+export declare const YwikiCodeBlock: import("@tiptap/core").Node<YwikiCodeOptions, any>;
+export {};

package/dist/types/editor/DocumentColorPanel.d.ts

@@ -0,0 +1,8 @@
+export declare function DocumentColorPanel({ textColor, highlightColor, onTextColor, onHighlightColor, onReset, onClose }: {
+    textColor: string | null;
+    highlightColor: string | null;
+    onTextColor: (value: string | null) => void;
+    onHighlightColor: (value: string | null) => void;
+    onReset: () => void;
+    onClose?: () => void;
+}): import("react").JSX.Element;

package/dist/types/editor/DocumentEditor.d.ts

@@ -0,0 +1,71 @@
+import type { Doc } from 'yjs';
+import type { Awareness } from 'y-protocols/awareness';
+import type { ProseMirrorDoc, ProseMirrorNode, CommentItem } from 'wendang/types';
+import { type InlineAnchor } from 'wendang/shared';
+import type { MindMapViewState } from 'wendang/mindmap';
+export interface DocumentEditorProps {
+    value?: ProseMirrorDoc;
+    defaultValue?: ProseMirrorDoc;
+    disabled?: boolean;
+    placeholder?: string;
+    schemaVersion?: number;
+    allowExport?: boolean;
+    canComment?: boolean;
+    pageId?: string;
+    spaceId?: string;
+    saveStatus?: string;
+    inlineComments?: CommentItem[];
+    activeCommentId?: string | null;
+    collabDoc?: Doc | null;
+    collabAwareness?: Awareness | null;
+    mindMapViewState?: MindMapViewState;
+    uploadImage?: (file: File) => Promise<{
+        id: string;
+        alt: string;
+    }>;
+    uploadFile?: (file: File) => Promise<{
+        id: string;
+        filename: string;
+        mimeType: string;
+        size: number;
+    }>;
+    onChange?: (value: ProseMirrorDoc, meta?: {
+        remote?: boolean;
+    }) => void;
+    onReady?: () => void;
+    onBlur?: () => void;
+    onError?: (error: Error) => void;
+    onNotice?: (notice: string) => void;
+    onRequestComment?: () => void;
+    onInlineMarkClick?: (id: string) => void;
+    onCommentsChanged?: () => void;
+    onSharePage?: () => void;
+    onConvertToSubpage?: (node: ProseMirrorNode) => void;
+    onSaveAsTemplate?: (node: ProseMirrorNode) => void;
+    className?: string;
+}
+export interface DocumentEditorHandle {
+    isReady: () => boolean;
+    whenReady: () => Promise<void>;
+    getJSON: () => ProseMirrorDoc;
+    getSnapshot: () => ProseMirrorDoc;
+    prepareSnapshot: () => Promise<{
+        doc: ProseMirrorDoc;
+        schemaVersion: number;
+    }>;
+    setContent: (doc: ProseMirrorDoc | null) => void;
+    hasPendingTasks: () => boolean;
+    hasSelection: () => boolean;
+    focus: () => void;
+    undo: () => boolean;
+    redo: () => boolean;
+    getSelectionRect: () => {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    } | null;
+    getSelectionForAnchor: () => InlineAnchor | null;
+    setSelection: (from: number, to?: number) => void;
+}
+export declare const DocumentEditor: import("react").ForwardRefExoticComponent<DocumentEditorProps & import("react").RefAttributes<DocumentEditorHandle>>;

package/dist/types/editor/ImagePreview.d.ts

@@ -0,0 +1,10 @@
+import { previewItemsFrom, type PreviewItem } from '../engine/shared/preview-items';
+export { previewItemsFrom };
+export declare function ImagePreview({ src, label, items, index, onClose }: {
+    src: string;
+    label?: string;
+    items?: PreviewItem[];
+    index?: number;
+    onClose: () => void;
+    allowExport?: boolean;
+}): import("react").ReactPortal | null;

package/dist/types/editor/LinkPopover.d.ts

@@ -0,0 +1,21 @@
+import { type LinkEditTarget } from '../engine/editor/link-edit';
+export interface LinkTarget {
+    href: string;
+    from: number;
+    to: number;
+    tracked?: LinkEditTarget;
+    mode: 'edit' | 'preview';
+    anchor: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+}
+export declare function LinkPopover({ target, onEdit, onSave, onRemove, onClose }: {
+    target: LinkTarget;
+    onEdit: () => void;
+    onSave: (href: string) => void;
+    onRemove: () => void;
+    onClose: () => void;
+}): import("react").ReactPortal | null;

package/dist/types/editor/PagePicker.d.ts

@@ -0,0 +1,7 @@
+export declare function PagePicker({ spaceId, excludeId, title, onClose, onPick }: {
+    spaceId?: string;
+    excludeId?: string;
+    title?: string;
+    onClose: () => void;
+    onPick: (id: string, title: string) => void;
+}): import("react").ReactPortal | null;

package/dist/types/editor/SelectionToolbar.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from '@tiptap/core';
+export interface SelectionToolbarProps {
+    editor: Editor;
+    x: number;
+    y: number;
+    canComment?: boolean;
+    onRequestComment?: () => void;
+    onRequestLink?: () => void;
+    onRemoveLink?: () => void;
+}
+export declare function SelectionToolbar({ editor, x, y, canComment, onRequestComment, onRequestLink, onRemoveLink }: SelectionToolbarProps): import("react").JSX.Element;

package/dist/types/editor/SlashMenu.d.ts

@@ -0,0 +1,30 @@
+import type { Editor } from '@tiptap/core';
+import { WButton } from '../wui';
+export interface SlashMenuProps {
+    editor: Editor;
+    from: number;
+    query: string;
+    x: number;
+    y: number;
+    onClose: () => void;
+    onPickFile: (kind: 'image' | 'file') => void;
+    onPickPage: () => void;
+    onPickVideo: () => void;
+}
+type PanelValue = {
+    rows?: number;
+    cols?: number;
+    count?: number;
+};
+export declare function InsertPicker({ mode, x, y, yBottom, boundTop, boundBottom, onPick, onClose }: {
+    mode: 'table' | 'columns';
+    x: number;
+    y: number;
+    yBottom?: number;
+    boundTop?: number;
+    boundBottom?: number;
+    onPick: (value: PanelValue) => void;
+    onClose: () => void;
+}): import("react").JSX.Element;
+export declare function SlashMenu({ editor, from, query, x, y, onClose, onPickFile, onPickPage, onPickVideo }: SlashMenuProps): import("react").JSX.Element;
+export { WButton };

package/dist/types/editor/TableControls.d.ts

@@ -0,0 +1,9 @@
+import type { Editor } from '@tiptap/core';
+import { type TableGeometry } from '../engine/editor/table-geometry';
+export declare function TableControls({ editor, hover, revision, onNotice, onBlockDrag }: {
+    editor: Editor;
+    hover: TableGeometry | null;
+    revision: number;
+    onNotice?: (message: string) => void;
+    onBlockDrag?: (pos: number, event: MouseEvent, onClick: () => void) => void;
+}): import("react").JSX.Element;

package/dist/types/editor/VideoEmbedDialog.d.ts

@@ -0,0 +1,6 @@
+import { type VideoEmbedData } from 'wendang/internal/video-embed';
+export declare function VideoEmbedDialog({ initialUrl, onClose, onInsert }: {
+    initialUrl?: string;
+    onClose: () => void;
+    onInsert: (video: VideoEmbedData) => void;
+}): import("react").JSX.Element;

package/dist/types/editor/document-gestures.d.ts

@@ -0,0 +1,13 @@
+import type { Editor } from '@tiptap/core';
+export declare function documentGestures(editor: Editor, shell: HTMLElement, options: {
+    layer: () => HTMLElement;
+    onStart: () => void;
+    onEnd: () => void;
+    onImagePick: (pos: number | null) => void;
+    onPreview: (image: HTMLImageElement) => void;
+}): {
+    start: (pos: number, event: MouseEvent, onClick?: () => void) => void;
+    consumeClick: () => boolean;
+    cancel: () => void;
+    destroy(): void;
+};

package/dist/types/editor/extensions.d.ts

@@ -0,0 +1,29 @@
+import type { Extensions, NodeViewRenderer } from '@tiptap/core';
+import type { Doc } from 'yjs';
+import type { Awareness } from 'y-protocols/awareness';
+import { type InlineCommentHighlightOptions } from '../engine/editor/extensions/inline-comments';
+import { type SlashOptions } from '../engine/editor/extensions/slash';
+import { type BlockHandleOptions } from '../engine/editor/extensions/block-handle';
+import { type UploadPlaceholderOptions } from '../engine/editor/extensions/upload-placeholder';
+import { type TableInteractionOptions } from '../engine/editor/extensions/table-interaction';
+import type { AttachmentFetcher } from '../host-types';
+import type { ContentContext } from '../host';
+export declare const COLLAB_FIELD = "default";
+export interface CoreExtensionOptions {
+    placeholder?: string;
+    collabDoc?: Doc | null;
+    collabField?: string;
+    collabAwareness?: Awareness | null;
+    attachmentFetcher?: AttachmentFetcher;
+    attachmentScope?: string;
+    inlineComments?: InlineCommentHighlightOptions;
+    slash?: SlashOptions;
+    blockHandle?: BlockHandleOptions;
+    uploadPlaceholder?: UploadPlaceholderOptions;
+    tableInteraction?: TableInteractionOptions;
+    mindMapRenderer?: NodeViewRenderer;
+    videoRenderer?: NodeViewRenderer;
+    canCopyCode?: () => boolean;
+    contentContext?: () => ContentContext;
+}
+export declare function coreExtensions(options?: CoreExtensionOptions): Extensions;

package/dist/types/editor/nodes.d.ts

@@ -0,0 +1,20 @@
+import { Node, type NodeViewRenderer } from '@tiptap/core';
+export { Columns, Column, buildColumnsJson } from '../engine/editor/nodes/columns';
+export { FileAttachment } from '../engine/editor/nodes/file';
+export { YwikiImage } from '../engine/editor/nodes/image';
+export { ImageGallery } from '../engine/editor/nodes/image-gallery';
+export { TextStyle, Highlight } from '../engine/editor/nodes/inline-style';
+export { MathInline, MathBlock } from '../engine/editor/nodes/math';
+export { PageLink } from '../engine/editor/nodes/page-link';
+export { Mention } from '../engine/editor/nodes/mention';
+export { AlignedTableCell, AlignedTableHeader } from '../engine/editor/nodes/table-cell';
+export declare const Callout: Node<{
+    renderer?: NodeViewRenderer;
+}, any>;
+export { MindMapTopic, MindMapDescription, MindMapNote, MindMapRelation } from '../engine/editor/nodes/mind-map-schema';
+export declare const MindMap: Node<{
+    renderer?: NodeViewRenderer;
+}, any>;
+export declare const VideoEmbed: Node<{
+    renderer?: NodeViewRenderer;
+}, any>;

package/dist/types/editor/same-document.d.ts

@@ -0,0 +1,2 @@
+import type { ProseMirrorDoc } from 'wendang/types';
+export declare function sameDocument(a: ProseMirrorDoc | null | undefined, b: ProseMirrorDoc | null | undefined): boolean;

package/dist/types/engine/collab/presence.d.ts

@@ -0,0 +1 @@
+export * from 'wendang/internal/presence';

package/dist/types/engine/editor/block-commands.d.ts

@@ -0,0 +1,35 @@
+import type { Editor } from '@tiptap/core';
+export type BlockCommandGroup = 'basic' | 'common';
+export interface BlockCommand {
+    id: string;
+    label: string;
+    hint: string;
+    group: BlockCommandGroup;
+    icon: string;
+    convertible?: boolean;
+    panel?: 'table' | 'columns';
+    keywords: string[];
+    run: (ctx: BlockCommandContext) => void;
+}
+export interface BlockCommandContext {
+    chain: () => ReturnType<Editor['chain']>;
+    requestPickFile?: (kind: 'image' | 'file') => void;
+    requestPickPage?: () => void;
+    requestVideo?: () => void;
+    panelValue?: {
+        rows?: number;
+        cols?: number;
+        count?: number;
+    };
+}
+export declare const BLOCK_COMMANDS: BlockCommand[];
+export declare const BLOCK_COMMAND_GROUPS: Array<{
+    id: BlockCommandGroup;
+    label: string;
+}>;
+export declare function filterBlockCommands(query: string): BlockCommand[];
+export declare function groupOf(commands: BlockCommand[]): Array<{
+    id: BlockCommandGroup;
+    label: string;
+    items: BlockCommand[];
+}>;

package/dist/types/engine/editor/block-conversion.d.ts

@@ -0,0 +1,12 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as PMNode } from '@tiptap/pm/model';
+import { type EditorState } from '@tiptap/pm/state';
+export declare const BLOCK_TEXTUAL_TYPES: readonly ["paragraph", "heading", "blockquote", "codeBlock", "bulletList", "orderedList", "taskList", "callout"];
+export interface MenuBlockRange {
+    from: number;
+    to: number;
+    nodes: PMNode[];
+}
+export declare function menuBlockRange(state: EditorState, pos: number): MenuBlockRange | null;
+export declare function canConvertMenuBlocks(state: EditorState, pos: number, id: string): boolean;
+export declare function convertMenuBlocks(editor: Editor, pos: number, id: string): boolean;

package/dist/types/engine/editor/block-drag.d.ts

@@ -0,0 +1,16 @@
+export interface GapCandidate {
+    pos: number;
+    y: number;
+}
+export declare function pickNearestGap(gaps: GapCandidate[], pointerY: number): GapCandidate | null;
+export interface MovePlan {
+    deleteFrom: number;
+    deleteTo: number;
+    insertAt: number;
+}
+export declare function planBlockMove(params: {
+    docSize: number;
+    from: number;
+    size: number;
+    gapPos: number;
+}): MovePlan | null;

package/dist/types/engine/editor/block-menu-placement.d.ts

@@ -0,0 +1,16 @@
+export declare const BLOCK_SUBMENU_GAP = 6;
+export declare const BLOCK_MENU_VIEW_MARGIN = 8;
+export declare function placeBlockSubmenu(parent: {
+    left: number;
+    right: number;
+}, rowTop: number, panel: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}): {
+    left: number;
+    top: number;
+    maxHeight: number;
+};

package/dist/types/engine/editor/callout-commands.d.ts

@@ -0,0 +1,4 @@
+import type { Editor } from '@tiptap/core';
+import { type CalloutAttrs } from '../shared/callout';
+export declare function patchCallout(editor: Editor, pos: number, attrs: CalloutAttrs): boolean;
+export declare function unwrapCallout(editor: Editor, pos: number): boolean;

package/dist/types/engine/editor/collab-change-origin.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from '@tiptap/pm/state';
+export declare function isRemoteDocumentChange(transaction: Pick<Transaction, 'getMeta'>): boolean;

package/dist/types/engine/editor/delete-block.d.ts

@@ -0,0 +1,2 @@
+import type { EditorState, Transaction } from '@tiptap/pm/state';
+export declare function deleteTopLevelBlock(state: EditorState, pos: number): Transaction | null;

package/dist/types/engine/editor/extensions/block-format.d.ts

@@ -0,0 +1,19 @@
+import { Extension } from '@tiptap/core';
+export declare const TEXT_ALIGNS: readonly ["left", "center", "right", "justify"];
+export type TextAlign = (typeof TEXT_ALIGNS)[number];
+export declare const MAX_INDENT = 6;
+export declare const INDENT_STEP_PX = 24;
+export interface BlockFormatOptions {
+    types?: string[];
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        blockFormat: {
+            setTextAlign: (align: TextAlign | null) => ReturnType;
+            indentBlock: () => ReturnType;
+            outdentBlock: () => ReturnType;
+            setIndent: (level: number) => ReturnType;
+        };
+    }
+}
+export declare const BlockFormat: Extension<BlockFormatOptions, any>;

package/dist/types/engine/editor/extensions/block-handle.d.ts

@@ -0,0 +1,17 @@
+import { Extension } from '@tiptap/core';
+import { PluginKey } from '@tiptap/pm/state';
+export interface BlockHoverInfo {
+    pos: number;
+    type: string;
+    top: number;
+    contentLeft: number;
+    isEmpty: boolean;
+}
+export interface BlockHandleOptions {
+    onHover: (info: BlockHoverInfo | null) => void;
+}
+export declare function isEmptyLineBlock(typeName: string, contentSize: number): boolean;
+export declare const BlockHandleKey: PluginKey<{
+    dummy: true;
+}>;
+export declare const BlockHandle: Extension<BlockHandleOptions, any>;

package/dist/types/engine/editor/extensions/block-menu-highlight.d.ts

@@ -0,0 +1,4 @@
+import { Extension } from '@tiptap/core';
+import type { EditorView } from '@tiptap/pm/view';
+export declare const BlockMenuHighlight: Extension<any, any>;
+export declare function highlightMenuBlock(view: EditorView, pos: number | null): void;

package/dist/types/engine/editor/extensions/block-selection.d.ts

@@ -0,0 +1,117 @@
+import { Extension } from '@tiptap/core';
+import { PluginKey, Selection } from '@tiptap/pm/state';
+import type { Transaction } from '@tiptap/pm/state';
+import { Slice } from '@tiptap/pm/model';
+import type { ResolvedPos } from '@tiptap/pm/model';
+import type { Mapping } from '@tiptap/pm/transform';
+import type { EditorView } from '@tiptap/pm/view';
+import type { Node as PMNode } from '@tiptap/pm/model';
+export interface SelectionPadding {
+    top: number;
+    bottom: number;
+}
+export interface SelectedBlock {
+    from: number;
+    to: number;
+    padding?: SelectionPadding;
+    images?: SelectionPart[];
+}
+export interface SelectionPart {
+    from: number;
+    to: number;
+}
+export type BlockSelectionPart = {
+    kind: 'block';
+    from: number;
+    to: number;
+} | {
+    kind: 'images';
+    from: number;
+    to: number;
+    images: SelectionPart[];
+};
+export declare const blockSelectionKey: PluginKey<{
+    blocks: SelectedBlock[];
+}>;
+export declare const SELECT_PAD_X = 6;
+export declare const SELECT_PAD_Y = 5;
+export interface BlockSelectionBand {
+    left: number;
+    right: number;
+}
+export declare function blockSelectionBand(view: EditorView): BlockSelectionBand;
+export declare function blockSelectionBandRect(view: EditorView): DOMRect | null;
+export declare function bandSide(x: number, proseLeft: number, proseRight: number, band: BlockSelectionBand): 'left' | 'right' | null;
+export declare function scrollParentOf(element: Element | null): HTMLElement | null;
+export declare function autoScrollDelta(pointerY: number, top: number, bottom: number, edge?: number, maxSpeed?: number): number;
+export declare class BlockRangeSelection extends Selection {
+    readonly parts?: BlockSelectionPart[];
+    constructor($from: ResolvedPos, $to: ResolvedPos, parts?: BlockSelectionPart[]);
+    visible: boolean;
+    content(): Slice;
+    replace(tr: Transaction, content?: Slice): void;
+    eq(other: Selection): boolean;
+    map(doc: PMNode, mapping: Mapping): Selection;
+    toJSON(): {
+        type: string;
+        from: number;
+        to: number;
+        parts: BlockSelectionPart[] | undefined;
+    };
+    static fromJSON(doc: PMNode, json: {
+        from: number;
+        to: number;
+        parts?: BlockSelectionPart[];
+    }): BlockRangeSelection;
+    getBookmark(): import("@tiptap/pm/state").SelectionBookmark;
+}
+interface BlockHit {
+    pos: number;
+    node: PMNode;
+}
+export declare function gutterAreaHit(view: EditorView, event: MouseEvent): BlockHit | null;
+export declare function coveredBlocks(doc: PMNode, aPos: number, bPos: number): Array<{
+    from: number;
+    to: number;
+}>;
+export interface MarqueeRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export declare function rectsIntersect(a: MarqueeRect, b: MarqueeRect): boolean;
+export declare function marqueeImageRanges(galleryFrom: number, sizes: readonly number[], childRects: ReadonlyArray<MarqueeRect | null>, marquee: MarqueeRect): SelectionPart[];
+export declare function selectionPartsForRange(view: EditorView, doc: PMNode, aPos: number, bPos: number, marquee: MarqueeRect): BlockSelectionPart[];
+export declare function marqueeBox(startX: number, startY: number, x: number, y: number, hostLeft: number, hostTop: number): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export declare function clampMarqueeBand(bandLeft: number, bandRight: number, hostLeft: number, hostRight: number, viewportRight?: number): {
+    left: number;
+    right: number;
+};
+export declare const BLOCK_SELECT_SLOP_PX = 8;
+export declare function isBlockSelectGesture(dx: number, dy: number): boolean;
+export declare function gutterClickCaretPos(doc: PMNode, pos: number): number | null;
+export declare function shouldSuppressNativeHighlight(blocks: Array<{
+    from: number;
+    to: number;
+}> | undefined): boolean;
+export declare const MIN_BAND_GAP = 6;
+export declare function selectionPadding(rects: ReadonlyArray<{
+    top: number;
+    bottom: number;
+}>): SelectionPadding[];
+export declare function measureBlocksPadding(view: EditorView, blocks: ReadonlyArray<{
+    from: number;
+    to: number;
+}>): SelectionPadding[];
+export declare function setBlockRangeSelection(view: EditorView, anchorPos: number, targetPos: number, marquee?: MarqueeRect): boolean;
+export declare function clearBlockRangeSelection(view: EditorView): void;
+export declare function setImageRangeSelection(view: EditorView, galleryPos: number, imageRanges: SelectionPart[]): boolean;
+export declare function getSelectedBlocks(view: EditorView): SelectedBlock[];
+export declare const BlockSelection: Extension<any, any>;
+export {};

package/dist/types/engine/editor/extensions/code-highlight.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const CodeHighlight: Extension<any, any>;

package/dist/types/engine/editor/extensions/collab-cursor.d.ts

@@ -0,0 +1,13 @@
+import { Extension } from '@tiptap/core';
+import { PluginKey } from '@tiptap/pm/state';
+import type { Awareness } from 'y-protocols/awareness';
+export interface CollabCursorOptions {
+    awareness: Awareness | null;
+}
+export declare const CollabCursorPluginKey: PluginKey<any>;
+export declare function buildCursor(user: {
+    name?: string;
+    color?: string;
+    colorLight?: string;
+}): HTMLElement;
+export declare const CollabCursor: Extension<CollabCursorOptions, any>;

package/dist/types/engine/editor/extensions/ime-guard.d.ts

@@ -0,0 +1,8 @@
+import { Extension } from '@tiptap/core';
+import { PluginKey } from '@tiptap/pm/state';
+import { shouldIgnoreForIme } from '../ime/composition-state';
+export declare const imeKey: PluginKey<{
+    composing: boolean;
+}>;
+export declare const ImeGuard: Extension<any, any>;
+export { shouldIgnoreForIme };

package/dist/types/engine/editor/extensions/inline-comments.d.ts

@@ -0,0 +1,15 @@
+import { Extension, type Editor } from '@tiptap/core';
+import { PluginKey } from '@tiptap/pm/state';
+import type { CommentItem } from 'wendang/types';
+export interface InlineCommentHighlightOptions {
+    getComments: () => CommentItem[];
+    getActiveId?: () => string | null;
+    onMarkClick?: (commentId: string) => void;
+}
+interface PluginState {
+    comments: CommentItem[];
+}
+export declare const inlineCommentPluginKey: PluginKey<PluginState>;
+export declare const InlineCommentHighlight: Extension<InlineCommentHighlightOptions, any>;
+export declare function refreshInlineComments(editor: Editor, comments: CommentItem[]): void;
+export {};

package/dist/types/engine/editor/extensions/paste-sanitizer.d.ts

@@ -0,0 +1,4 @@
+import { Extension } from '@tiptap/core';
+export declare const PasteSanitizer: Extension<any, any>;
+export declare function pastedImageFiles(event: ClipboardEvent): File[];
+export declare function pastedRemoteImageUrls(event: ClipboardEvent): string[];