@henryx/pagely 0.1.1 → 0.2.0

package/dist/components/DotFlowPadBlockView.vue.d.ts

@@ -101,8 +101,50 @@ declare const _default: import('vue').DefineComponent<NodeViewProps, {}, {}, {},
         };
     }) | null;
     inlineWrap: HTMLDivElement;
-    inlineRef: any;
+    inlineRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        initialData?: unknown;
+        readonly?: boolean;
+    }>, {
+        getData: () => unknown;
+        setData: (data: unknown) => void;
+        fitView?: () => void;
+    }, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        initialData?: unknown;
+        readonly?: boolean;
+    }>, {
+        getData: () => unknown;
+        setData: (data: unknown) => void;
+        fitView?: () => void;
+    }, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
     fullscreenWrap: HTMLDivElement;
-    fullscreenRef: any;
+    fullscreenRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        initialData?: unknown;
+        readonly?: boolean;
+    }>, {
+        getData: () => unknown;
+        setData: (data: unknown) => void;
+        fitView?: () => void;
+    }, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        initialData?: unknown;
+        readonly?: boolean;
+    }>, {
+        getData: () => unknown;
+        setData: (data: unknown) => void;
+        fitView?: () => void;
+    }, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
 }, any>;
 export default _default;

package/dist/components/PagelyEditor.vue.d.ts

@@ -3,9 +3,11 @@ import { AnchorSpec, CommentAnchor, CommentClickPayload, CommentCreateSpec, Comm
 import { MentionAnchor, MentionTriggerPayload } from '../composables/useMention';
 import { MentionAttrs } from '../extensions/Mention';
 import { FileUploadHandler } from '../composables/useFileUpload';
+import { ImageUrlResolver } from '../extensions/Image';
 type __VLS_Props = {
     initialContent?: string;
     fileUploadHandler?: FileUploadHandler;
+    imageUrlResolver?: ImageUrlResolver;
     enableComment?: boolean;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {

package/dist/components/PagelyPage.vue.d.ts

@@ -0,0 +1,476 @@
+import { Editor } from '@tiptap/vue-3';
+import { AnchorSpec, CommentAnchor, CommentClickPayload, CommentCreateSpec, CommentHoverPayload } from '../composables/useCommentAnchors';
+import { FileUploadHandler } from '../composables/useFileUpload';
+import { MentionAnchor, MentionTriggerPayload } from '../composables/useMention';
+import { MentionAttrs } from '../extensions/Mention';
+import { ImageUrlResolver } from '../extensions/Image';
+type PagelyPageMode = 'edit' | 'view';
+type PagelyPageFormat = 'html' | 'markdown';
+type __VLS_Props = {
+    mode?: PagelyPageMode;
+    content?: string;
+    format?: PagelyPageFormat;
+    initialContent?: string;
+    fileUploadHandler?: FileUploadHandler;
+    imageUrlResolver?: ImageUrlResolver;
+    enableComment?: boolean;
+    tocMaxLevel?: number;
+};
+declare function refreshToc(): void;
+declare function getHtml(): string;
+declare function getMarkdown(): string;
+declare function setMarkdown(md: string): void;
+declare function setHtml(html: string): void;
+declare function setContent(content: string, format?: PagelyPageFormat): void;
+declare function getEditor(): Editor | undefined;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        after?(_: {}): any;
+    };
+    refs: {
+        scrollRef: HTMLElement;
+        editorRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            initialContent?: string;
+            fileUploadHandler?: FileUploadHandler;
+            imageUrlResolver?: ImageUrlResolver;
+            enableComment?: boolean;
+        }> & Readonly<{
+            "onUpdate:markdown"?: ((md: string) => any) | undefined;
+            "onUpdate:html"?: ((html: string) => any) | undefined;
+            "onComment:create"?: ((spec: CommentCreateSpec) => any) | undefined;
+            "onComment:click"?: ((payload: CommentClickPayload) => any) | undefined;
+            "onComment:hover"?: ((payload: CommentHoverPayload | null) => any) | undefined;
+            "onComment:orphaned"?: ((payload: {
+                commentId: string;
+            }) => any) | undefined;
+            "onComment:anchor-drift"?: ((payload: {
+                commentId: string;
+            }) => any) | undefined;
+            "onAnchors-changed"?: ((anchors: CommentAnchor[]) => any) | undefined;
+            "onMention:trigger"?: ((payload: MentionTriggerPayload) => any) | undefined;
+            "onMention:cancel"?: (() => any) | undefined;
+        }>, {
+            getHtml: () => string;
+            getMarkdown: () => string;
+            setMarkdown: (md: string) => void;
+            setHtml: (html: string) => void;
+            getEditor: () => Editor | undefined;
+            getCommentAnchors: () => CommentAnchor[];
+            applyCommentAnchors: (anchors: CommentAnchor[]) => boolean;
+            addComment: (commentId: string, spec: AnchorSpec) => boolean;
+            removeCommentAnchor: (commentId: string) => boolean;
+            getMentions: () => MentionAnchor[];
+            applyMentions: (mentions: MentionAnchor[]) => boolean;
+            insertMention: (attrs: MentionAttrs) => boolean;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:markdown": (md: string) => any;
+            "update:html": (html: string) => any;
+            "comment:create": (spec: CommentCreateSpec) => any;
+            "comment:click": (payload: CommentClickPayload) => any;
+            "comment:hover": (payload: CommentHoverPayload | null) => any;
+            "comment:orphaned": (payload: {
+                commentId: string;
+            }) => any;
+            "comment:anchor-drift": (payload: {
+                commentId: string;
+            }) => any;
+            "anchors-changed": (anchors: CommentAnchor[]) => any;
+            "mention:trigger": (payload: MentionTriggerPayload) => any;
+            "mention:cancel": () => any;
+        }, import('vue').PublicProps, {
+            enableComment: boolean;
+            initialContent: string;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            wrapRef: HTMLDivElement;
+            insertBtnRef: HTMLButtonElement;
+            pillRef: HTMLDivElement;
+            linkToolbarRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+                editor: Editor | undefined;
+            }> & Readonly<{}>, {
+                show: (url: string, text: string, anchorRect: DOMRect) => void;
+                hide: (immediate?: boolean) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                toolbarEl: HTMLDivElement;
+                viewWrapEl: HTMLDivElement;
+                editInputEl: HTMLInputElement;
+            }, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                editor: Editor | undefined;
+            }> & Readonly<{}>, {
+                show: (url: string, text: string, anchorRect: DOMRect) => void;
+                hide: (immediate?: boolean) => void;
+            }, {}, {}, {}, {}> | null;
+            selToolbarRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+                editor: Editor | undefined;
+                enableComment?: boolean;
+            }> & Readonly<{
+                onComment?: (() => any) | undefined;
+            }>, {
+                show: (rect: DOMRect) => void;
+                hide: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                comment: () => any;
+            }, import('vue').PublicProps, {
+                enableComment: boolean;
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                toolbarEl: HTMLDivElement;
+                linkInputEl: HTMLInputElement;
+                typeWrapEl: HTMLDivElement;
+                colorWrapEl: HTMLDivElement;
+            }, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                editor: Editor | undefined;
+                enableComment?: boolean;
+            }> & Readonly<{
+                onComment?: (() => any) | undefined;
+            }>, {
+                show: (rect: DOMRect) => void;
+                hide: () => void;
+            }, {}, {}, {}, {
+                enableComment: boolean;
+            }> | null;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            initialContent?: string;
+            fileUploadHandler?: FileUploadHandler;
+            imageUrlResolver?: ImageUrlResolver;
+            enableComment?: boolean;
+        }> & Readonly<{
+            "onUpdate:markdown"?: ((md: string) => any) | undefined;
+            "onUpdate:html"?: ((html: string) => any) | undefined;
+            "onComment:create"?: ((spec: CommentCreateSpec) => any) | undefined;
+            "onComment:click"?: ((payload: CommentClickPayload) => any) | undefined;
+            "onComment:hover"?: ((payload: CommentHoverPayload | null) => any) | undefined;
+            "onComment:orphaned"?: ((payload: {
+                commentId: string;
+            }) => any) | undefined;
+            "onComment:anchor-drift"?: ((payload: {
+                commentId: string;
+            }) => any) | undefined;
+            "onAnchors-changed"?: ((anchors: CommentAnchor[]) => any) | undefined;
+            "onMention:trigger"?: ((payload: MentionTriggerPayload) => any) | undefined;
+            "onMention:cancel"?: (() => any) | undefined;
+        }>, {
+            getHtml: () => string;
+            getMarkdown: () => string;
+            setMarkdown: (md: string) => void;
+            setHtml: (html: string) => void;
+            getEditor: () => Editor | undefined;
+            getCommentAnchors: () => CommentAnchor[];
+            applyCommentAnchors: (anchors: CommentAnchor[]) => boolean;
+            addComment: (commentId: string, spec: AnchorSpec) => boolean;
+            removeCommentAnchor: (commentId: string) => boolean;
+            getMentions: () => MentionAnchor[];
+            applyMentions: (mentions: MentionAnchor[]) => boolean;
+            insertMention: (attrs: MentionAttrs) => boolean;
+        }, {}, {}, {}, {
+            enableComment: boolean;
+            initialContent: string;
+        }> | null;
+        viewerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            content: string;
+            format?: "markdown" | "html";
+            imageUrlResolver?: ImageUrlResolver;
+        }> & Readonly<{}>, {
+            getHtml: () => string;
+            getMarkdown: () => string;
+            setContent: (content: string, format?: "markdown" | "html") => void;
+            getEditor: () => Editor | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            format: "markdown" | "html";
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            content: string;
+            format?: "markdown" | "html";
+            imageUrlResolver?: ImageUrlResolver;
+        }> & Readonly<{}>, {
+            getHtml: () => string;
+            getMarkdown: () => string;
+            setContent: (content: string, format?: "markdown" | "html") => void;
+            getEditor: () => Editor | undefined;
+        }, {}, {}, {}, {
+            format: "markdown" | "html";
+        }> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    getHtml: typeof getHtml;
+    getMarkdown: typeof getMarkdown;
+    setMarkdown: typeof setMarkdown;
+    setHtml: typeof setHtml;
+    setContent: typeof setContent;
+    getEditor: typeof getEditor;
+    refreshToc: typeof refreshToc;
+    getTocItems: () => {
+        id: string;
+        text: string;
+        level: number;
+        pos: number;
+    }[];
+    getCommentAnchors: () => CommentAnchor[];
+    applyCommentAnchors: (anchors: CommentAnchor[]) => boolean | undefined;
+    addComment: (commentId: string, spec: AnchorSpec) => boolean | undefined;
+    removeCommentAnchor: (commentId: string) => boolean | undefined;
+    getMentions: () => MentionAnchor[];
+    applyMentions: (mentions: MentionAnchor[]) => boolean | undefined;
+    insertMention: (attrs: MentionAttrs) => boolean | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:markdown": (md: string) => any;
+    "update:html": (html: string) => any;
+    "comment:create": (spec: CommentCreateSpec) => any;
+    "comment:click": (payload: CommentClickPayload) => any;
+    "comment:hover": (payload: CommentHoverPayload | null) => any;
+    "comment:orphaned": (payload: {
+        commentId: string;
+    }) => any;
+    "comment:anchor-drift": (payload: {
+        commentId: string;
+    }) => any;
+    "anchors-changed": (anchors: CommentAnchor[]) => any;
+    "mention:trigger": (payload: MentionTriggerPayload) => any;
+    "mention:cancel": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:markdown"?: ((md: string) => any) | undefined;
+    "onUpdate:html"?: ((html: string) => any) | undefined;
+    "onComment:create"?: ((spec: CommentCreateSpec) => any) | undefined;
+    "onComment:click"?: ((payload: CommentClickPayload) => any) | undefined;
+    "onComment:hover"?: ((payload: CommentHoverPayload | null) => any) | undefined;
+    "onComment:orphaned"?: ((payload: {
+        commentId: string;
+    }) => any) | undefined;
+    "onComment:anchor-drift"?: ((payload: {
+        commentId: string;
+    }) => any) | undefined;
+    "onAnchors-changed"?: ((anchors: CommentAnchor[]) => any) | undefined;
+    "onMention:trigger"?: ((payload: MentionTriggerPayload) => any) | undefined;
+    "onMention:cancel"?: (() => any) | undefined;
+}>, {
+    mode: PagelyPageMode;
+    format: PagelyPageFormat;
+    content: string;
+    enableComment: boolean;
+    initialContent: string;
+    tocMaxLevel: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    scrollRef: HTMLElement;
+    editorRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        initialContent?: string;
+        fileUploadHandler?: FileUploadHandler;
+        imageUrlResolver?: ImageUrlResolver;
+        enableComment?: boolean;
+    }> & Readonly<{
+        "onUpdate:markdown"?: ((md: string) => any) | undefined;
+        "onUpdate:html"?: ((html: string) => any) | undefined;
+        "onComment:create"?: ((spec: CommentCreateSpec) => any) | undefined;
+        "onComment:click"?: ((payload: CommentClickPayload) => any) | undefined;
+        "onComment:hover"?: ((payload: CommentHoverPayload | null) => any) | undefined;
+        "onComment:orphaned"?: ((payload: {
+            commentId: string;
+        }) => any) | undefined;
+        "onComment:anchor-drift"?: ((payload: {
+            commentId: string;
+        }) => any) | undefined;
+        "onAnchors-changed"?: ((anchors: CommentAnchor[]) => any) | undefined;
+        "onMention:trigger"?: ((payload: MentionTriggerPayload) => any) | undefined;
+        "onMention:cancel"?: (() => any) | undefined;
+    }>, {
+        getHtml: () => string;
+        getMarkdown: () => string;
+        setMarkdown: (md: string) => void;
+        setHtml: (html: string) => void;
+        getEditor: () => Editor | undefined;
+        getCommentAnchors: () => CommentAnchor[];
+        applyCommentAnchors: (anchors: CommentAnchor[]) => boolean;
+        addComment: (commentId: string, spec: AnchorSpec) => boolean;
+        removeCommentAnchor: (commentId: string) => boolean;
+        getMentions: () => MentionAnchor[];
+        applyMentions: (mentions: MentionAnchor[]) => boolean;
+        insertMention: (attrs: MentionAttrs) => boolean;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:markdown": (md: string) => any;
+        "update:html": (html: string) => any;
+        "comment:create": (spec: CommentCreateSpec) => any;
+        "comment:click": (payload: CommentClickPayload) => any;
+        "comment:hover": (payload: CommentHoverPayload | null) => any;
+        "comment:orphaned": (payload: {
+            commentId: string;
+        }) => any;
+        "comment:anchor-drift": (payload: {
+            commentId: string;
+        }) => any;
+        "anchors-changed": (anchors: CommentAnchor[]) => any;
+        "mention:trigger": (payload: MentionTriggerPayload) => any;
+        "mention:cancel": () => any;
+    }, import('vue').PublicProps, {
+        enableComment: boolean;
+        initialContent: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        wrapRef: HTMLDivElement;
+        insertBtnRef: HTMLButtonElement;
+        pillRef: HTMLDivElement;
+        linkToolbarRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            editor: Editor | undefined;
+        }> & Readonly<{}>, {
+            show: (url: string, text: string, anchorRect: DOMRect) => void;
+            hide: (immediate?: boolean) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            toolbarEl: HTMLDivElement;
+            viewWrapEl: HTMLDivElement;
+            editInputEl: HTMLInputElement;
+        }, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            editor: Editor | undefined;
+        }> & Readonly<{}>, {
+            show: (url: string, text: string, anchorRect: DOMRect) => void;
+            hide: (immediate?: boolean) => void;
+        }, {}, {}, {}, {}> | null;
+        selToolbarRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            editor: Editor | undefined;
+            enableComment?: boolean;
+        }> & Readonly<{
+            onComment?: (() => any) | undefined;
+        }>, {
+            show: (rect: DOMRect) => void;
+            hide: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            comment: () => any;
+        }, import('vue').PublicProps, {
+            enableComment: boolean;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            toolbarEl: HTMLDivElement;
+            linkInputEl: HTMLInputElement;
+            typeWrapEl: HTMLDivElement;
+            colorWrapEl: HTMLDivElement;
+        }, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            editor: Editor | undefined;
+            enableComment?: boolean;
+        }> & Readonly<{
+            onComment?: (() => any) | undefined;
+        }>, {
+            show: (rect: DOMRect) => void;
+            hide: () => void;
+        }, {}, {}, {}, {
+            enableComment: boolean;
+        }> | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        initialContent?: string;
+        fileUploadHandler?: FileUploadHandler;
+        imageUrlResolver?: ImageUrlResolver;
+        enableComment?: boolean;
+    }> & Readonly<{
+        "onUpdate:markdown"?: ((md: string) => any) | undefined;
+        "onUpdate:html"?: ((html: string) => any) | undefined;
+        "onComment:create"?: ((spec: CommentCreateSpec) => any) | undefined;
+        "onComment:click"?: ((payload: CommentClickPayload) => any) | undefined;
+        "onComment:hover"?: ((payload: CommentHoverPayload | null) => any) | undefined;
+        "onComment:orphaned"?: ((payload: {
+            commentId: string;
+        }) => any) | undefined;
+        "onComment:anchor-drift"?: ((payload: {
+            commentId: string;
+        }) => any) | undefined;
+        "onAnchors-changed"?: ((anchors: CommentAnchor[]) => any) | undefined;
+        "onMention:trigger"?: ((payload: MentionTriggerPayload) => any) | undefined;
+        "onMention:cancel"?: (() => any) | undefined;
+    }>, {
+        getHtml: () => string;
+        getMarkdown: () => string;
+        setMarkdown: (md: string) => void;
+        setHtml: (html: string) => void;
+        getEditor: () => Editor | undefined;
+        getCommentAnchors: () => CommentAnchor[];
+        applyCommentAnchors: (anchors: CommentAnchor[]) => boolean;
+        addComment: (commentId: string, spec: AnchorSpec) => boolean;
+        removeCommentAnchor: (commentId: string) => boolean;
+        getMentions: () => MentionAnchor[];
+        applyMentions: (mentions: MentionAnchor[]) => boolean;
+        insertMention: (attrs: MentionAttrs) => boolean;
+    }, {}, {}, {}, {
+        enableComment: boolean;
+        initialContent: string;
+    }> | null;
+    viewerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        content: string;
+        format?: "markdown" | "html";
+        imageUrlResolver?: ImageUrlResolver;
+    }> & Readonly<{}>, {
+        getHtml: () => string;
+        getMarkdown: () => string;
+        setContent: (content: string, format?: "markdown" | "html") => void;
+        getEditor: () => Editor | undefined;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        format: "markdown" | "html";
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        content: string;
+        format?: "markdown" | "html";
+        imageUrlResolver?: ImageUrlResolver;
+    }> & Readonly<{}>, {
+        getHtml: () => string;
+        getMarkdown: () => string;
+        setContent: (content: string, format?: "markdown" | "html") => void;
+        getEditor: () => Editor | undefined;
+    }, {}, {}, {}, {
+        format: "markdown" | "html";
+    }> | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/PagelyToc.vue.d.ts

@@ -0,0 +1,17 @@
+import { PagelyTocItem } from '../composables/usePagelyToc';
+type __VLS_Props = {
+    items: PagelyTocItem[];
+    activeId?: string;
+    collapsed?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:collapsed": (collapsed: boolean) => any;
+    "item-click": (item: PagelyTocItem) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:collapsed"?: ((collapsed: boolean) => any) | undefined;
+    "onItem-click"?: ((item: PagelyTocItem) => any) | undefined;
+}>, {
+    collapsed: boolean;
+    activeId: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/components/PagelyViewer.vue.d.ts

@@ -1,8 +1,10 @@
 import { Editor } from '@tiptap/vue-3';
+import { ImageUrlResolver } from '../extensions/Image';
 type ViewerFormat = 'html' | 'markdown';
 type __VLS_Props = {
     content: string;
     format?: ViewerFormat;
+    imageUrlResolver?: ImageUrlResolver;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {
     getHtml: () => string;

package/dist/composables/useFileUpload.d.ts

@@ -3,11 +3,16 @@ export declare const IMAGE_FILE_ACCEPT = "image/*,.png,.jpg,.jpeg,.gif,.webp,.bm
 export { DEFAULT_ATTACHMENT_ACCEPT, defaultAttachmentUpload, type FileUploadHandler, type FileUploadResult, };
 export interface ImageFilePayload {
     src: string;
-    alt: string;
+    attachmentId?: string | number | null;
+    fileName?: string | null;
+    mimeType?: string | null;
+    alt?: string | null;
+    title?: string | null;
 }
 export interface UseImageFileUploadOptions {
     onBeforeSelect?: () => void;
     onInsert: (payload: ImageFilePayload) => void;
+    uploadHandler?: FileUploadHandler;
 }
 export interface UseDocFileUploadOptions {
     onBeforeSelect?: () => void;

package/dist/composables/useHeadingCollapse.d.ts

@@ -1,8 +1,8 @@
 import { Ref } from 'vue';
 import { Editor } from '@tiptap/vue-3';
 import { Extension } from '@tiptap/core';
-import { DecorationSet } from 'prosemirror-view';
-import { PluginKey } from 'prosemirror-state';
+import { DecorationSet } from '@tiptap/pm/view';
+import { PluginKey } from '@tiptap/pm/state';
 interface CollapseState {
     collapsed: Set<number>;
     decorations: DecorationSet;

package/dist/composables/useLinkOps.d.ts

@@ -1,5 +1,5 @@
 import { Editor } from '@tiptap/vue-3';
-import { EditorState } from 'prosemirror-state';
+import { EditorState } from '@tiptap/pm/state';
 interface LinkRange {
     from: number;
     to: number;

package/dist/composables/usePagelyEditor.d.ts

@@ -1,5 +1,6 @@
 import { Ref } from 'vue';
 import { Content, Extension } from '@tiptap/core';
+import { ImageUrlResolver } from '../extensions/Image';
 import { ExtensionProfile } from '../config/extensionProfiles';
 import { FileUploadHandler } from '../utils/attachmentUpload';
 export interface UsePagelyEditorOptions {
@@ -13,5 +14,6 @@ export interface UsePagelyEditorOptions {
     onOpenMathPopover?: (node: unknown, pos: number, kind: 'inline' | 'block') => void;
     onOpenSlashInsert?: (blockPos: number, rect: DOMRect) => void;
     fileUploadHandler?: FileUploadHandler;
+    imageUrlResolver?: ImageUrlResolver;
 }
 export declare function usePagelyEditor(options: UsePagelyEditorOptions): import('vue').ShallowRef<import('@tiptap/vue-3').Editor | undefined, import('@tiptap/vue-3').Editor | undefined>;

package/dist/composables/usePagelyToc.d.ts

@@ -0,0 +1,50 @@
+import { ComputedRef, Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+type MaybeRef<T> = T | Ref<T> | ComputedRef<T>;
+export interface PagelyTocItem {
+    id: string;
+    text: string;
+    level: number;
+    pos: number;
+}
+export interface PagelyTocExtractOptions {
+    minLevel?: number;
+    maxLevel?: number;
+}
+export interface PagelyTocSourceNode {
+    type: {
+        name: string;
+    };
+    attrs?: Record<string, unknown>;
+    textContent?: string;
+}
+export interface PagelyTocSourceDoc {
+    descendants: (callback: (node: PagelyTocSourceNode, pos: number) => boolean | void) => void;
+}
+export interface UsePagelyTocOptions extends PagelyTocExtractOptions {
+    scrollContainer?: MaybeRef<HTMLElement | Window | null | undefined>;
+    scrollOffset?: MaybeRef<number | undefined>;
+    activeOffset?: MaybeRef<number | undefined>;
+    behavior?: MaybeRef<ScrollBehavior | undefined>;
+}
+export declare function slugifyTocId(value: string, fallback?: string): string;
+export declare function extractPagelyTocItemsFromDoc(doc: PagelyTocSourceDoc, options?: PagelyTocExtractOptions): PagelyTocItem[];
+export declare function extractPagelyTocItems(editor: Editor | null | undefined, options?: PagelyTocExtractOptions): PagelyTocItem[];
+export declare function usePagelyToc(editorSource: MaybeRef<Editor | null | undefined>, options?: UsePagelyTocOptions): {
+    items: Ref<{
+        id: string;
+        text: string;
+        level: number;
+        pos: number;
+    }[], PagelyTocItem[] | {
+        id: string;
+        text: string;
+        level: number;
+        pos: number;
+    }[]>;
+    activeId: Ref<string, string>;
+    refresh: () => void;
+    scrollToItem: (item: PagelyTocItem) => void;
+    updateActiveFromScroll: () => void;
+};
+export {};