@tiptap/vue-3 3.0.0-next.0 → 3.0.0-next.2

package/dist/index.d.ts

@@ -0,0 +1,303 @@
+import * as prosemirror_view from 'prosemirror-view';
+import * as _tiptap_core from '@tiptap/core';
+import { Editor as Editor$1, EditorOptions, NodeViewProps, NodeViewRendererOptions, NodeViewRenderer } from '@tiptap/core';
+export * from '@tiptap/core';
+import * as _floating_ui_core from '@floating-ui/core';
+import * as _floating_ui_dom from '@floating-ui/dom';
+import * as _floating_ui_utils from '@floating-ui/utils';
+import * as prosemirror_state from 'prosemirror-state';
+import * as vue from 'vue';
+import { PropType, AppContext, ComponentInternalInstance, ComponentPublicInstance, Ref, Component, h } from 'vue';
+import { BubbleMenuPluginProps } from '@tiptap/extension-bubble-menu';
+import { EditorState, Plugin, PluginKey } from '@tiptap/pm/state';
+import { FloatingMenuPluginProps } from '@tiptap/extension-floating-menu';
+import { Node } from '@tiptap/pm/model';
+import { Decoration, DecorationSource } from '@tiptap/pm/view';
+
+declare const BubbleMenu: vue.DefineComponent<vue.ExtractPropTypes<{
+    pluginKey: {
+        type: PropType<BubbleMenuPluginProps["pluginKey"]>;
+        default: string;
+    };
+    editor: {
+        type: PropType<BubbleMenuPluginProps["editor"]>;
+        required: true;
+    };
+    updateDelay: {
+        type: PropType<BubbleMenuPluginProps["updateDelay"]>;
+        default: undefined;
+    };
+    resizeDelay: {
+        type: PropType<BubbleMenuPluginProps["resizeDelay"]>;
+        default: undefined;
+    };
+    options: {
+        type: PropType<BubbleMenuPluginProps["options"]>;
+        default: () => {};
+    };
+    shouldShow: {
+        type: PropType<Exclude<Required<BubbleMenuPluginProps>["shouldShow"], null>>;
+        default: null;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    pluginKey: {
+        type: PropType<BubbleMenuPluginProps["pluginKey"]>;
+        default: string;
+    };
+    editor: {
+        type: PropType<BubbleMenuPluginProps["editor"]>;
+        required: true;
+    };
+    updateDelay: {
+        type: PropType<BubbleMenuPluginProps["updateDelay"]>;
+        default: undefined;
+    };
+    resizeDelay: {
+        type: PropType<BubbleMenuPluginProps["resizeDelay"]>;
+        default: undefined;
+    };
+    options: {
+        type: PropType<BubbleMenuPluginProps["options"]>;
+        default: () => {};
+    };
+    shouldShow: {
+        type: PropType<Exclude<Required<BubbleMenuPluginProps>["shouldShow"], null>>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    pluginKey: string | prosemirror_state.PluginKey<any>;
+    updateDelay: number | undefined;
+    resizeDelay: number | undefined;
+    options: {
+        strategy?: _floating_ui_utils.Strategy;
+        placement?: _floating_ui_utils.Placement;
+        offset?: _floating_ui_dom.OffsetOptions | boolean;
+        flip?: _floating_ui_dom.FlipOptions | boolean;
+        shift?: _floating_ui_dom.ShiftOptions | boolean;
+        arrow?: _floating_ui_dom.ArrowOptions | false;
+        size?: _floating_ui_dom.SizeOptions | boolean;
+        autoPlacement?: _floating_ui_dom.AutoPlacementOptions | boolean;
+        hide?: _floating_ui_dom.HideOptions | boolean;
+        inline?: _floating_ui_core.InlineOptions | boolean;
+    } | undefined;
+    shouldShow: (props: {
+        editor: _tiptap_core.Editor;
+        element: HTMLElement;
+        view: prosemirror_view.EditorView;
+        state: prosemirror_state.EditorState;
+        oldState?: prosemirror_state.EditorState;
+        from: number;
+        to: number;
+    }) => boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ContentComponent = ComponentInternalInstance & {
+    ctx: ComponentPublicInstance;
+};
+declare class Editor extends Editor$1 {
+    private reactiveState;
+    private reactiveExtensionStorage;
+    contentComponent: ContentComponent | null;
+    appContext: AppContext | null;
+    constructor(options?: Partial<EditorOptions>);
+    get state(): EditorState;
+    get storage(): Record<string, any>;
+    /**
+     * Register a ProseMirror plugin.
+     */
+    registerPlugin(plugin: Plugin, handlePlugins?: (newPlugin: Plugin, plugins: Plugin[]) => Plugin[]): EditorState;
+    /**
+     * Unregister a ProseMirror plugin.
+     */
+    unregisterPlugin(nameOrPluginKey: string | PluginKey): EditorState | undefined;
+}
+
+declare const EditorContent: vue.DefineComponent<vue.ExtractPropTypes<{
+    editor: {
+        default: null;
+        type: PropType<Editor>;
+    };
+}>, {
+    rootEl: Ref<Element | undefined, Element | undefined>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    editor: {
+        default: null;
+        type: PropType<Editor>;
+    };
+}>> & Readonly<{}>, {
+    editor: Editor;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const FloatingMenu: vue.DefineComponent<vue.ExtractPropTypes<{
+    pluginKey: {
+        type: null;
+        default: string;
+    };
+    editor: {
+        type: PropType<FloatingMenuPluginProps["editor"]>;
+        required: true;
+    };
+    options: {
+        type: PropType<BubbleMenuPluginProps["options"]>;
+        default: () => {};
+    };
+    shouldShow: {
+        type: PropType<Exclude<Required<FloatingMenuPluginProps>["shouldShow"], null>>;
+        default: null;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    pluginKey: {
+        type: null;
+        default: string;
+    };
+    editor: {
+        type: PropType<FloatingMenuPluginProps["editor"]>;
+        required: true;
+    };
+    options: {
+        type: PropType<BubbleMenuPluginProps["options"]>;
+        default: () => {};
+    };
+    shouldShow: {
+        type: PropType<Exclude<Required<FloatingMenuPluginProps>["shouldShow"], null>>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    pluginKey: any;
+    options: {
+        strategy?: _floating_ui_utils.Strategy;
+        placement?: _floating_ui_utils.Placement;
+        offset?: _floating_ui_dom.OffsetOptions | boolean;
+        flip?: _floating_ui_dom.FlipOptions | boolean;
+        shift?: _floating_ui_dom.ShiftOptions | boolean;
+        arrow?: _floating_ui_dom.ArrowOptions | false;
+        size?: _floating_ui_dom.SizeOptions | boolean;
+        autoPlacement?: _floating_ui_dom.AutoPlacementOptions | boolean;
+        hide?: _floating_ui_dom.HideOptions | boolean;
+        inline?: _floating_ui_core.InlineOptions | boolean;
+    } | undefined;
+    shouldShow: (props: {
+        editor: _tiptap_core.Editor;
+        view: prosemirror_view.EditorView;
+        state: prosemirror_state.EditorState;
+        oldState?: prosemirror_state.EditorState;
+        from: number;
+        to: number;
+    }) => boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const NodeViewContent: vue.DefineComponent<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    as: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const NodeViewWrapper: vue.DefineComponent<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    as: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const useEditor: (options?: Partial<EditorOptions>) => vue.ShallowRef<Editor | undefined, Editor | undefined>;
+
+declare const nodeViewProps: {
+    editor: {
+        type: PropType<NodeViewProps["editor"]>;
+        required: true;
+    };
+    node: {
+        type: PropType<NodeViewProps["node"]>;
+        required: true;
+    };
+    decorations: {
+        type: PropType<NodeViewProps["decorations"]>;
+        required: true;
+    };
+    selected: {
+        type: PropType<NodeViewProps["selected"]>;
+        required: true;
+    };
+    extension: {
+        type: PropType<NodeViewProps["extension"]>;
+        required: true;
+    };
+    getPos: {
+        type: PropType<NodeViewProps["getPos"]>;
+        required: true;
+    };
+    updateAttributes: {
+        type: PropType<NodeViewProps["updateAttributes"]>;
+        required: true;
+    };
+    deleteNode: {
+        type: PropType<NodeViewProps["deleteNode"]>;
+        required: true;
+    };
+};
+interface VueNodeViewRendererOptions extends NodeViewRendererOptions {
+    update: ((props: {
+        oldNode: Node;
+        oldDecorations: readonly Decoration[];
+        oldInnerDecorations: DecorationSource;
+        newNode: Node;
+        newDecorations: readonly Decoration[];
+        innerDecorations: DecorationSource;
+        updateProps: () => void;
+    }) => boolean) | null;
+}
+declare function VueNodeViewRenderer(component: Component<NodeViewProps>, options?: Partial<VueNodeViewRendererOptions>): NodeViewRenderer;
+
+interface VueRendererOptions {
+    editor: Editor$1;
+    props?: Record<string, any>;
+}
+type ExtendedVNode = ReturnType<typeof h> | null;
+interface RenderedComponent {
+    vNode: ExtendedVNode;
+    destroy: () => void;
+    el: Element | null;
+}
+/**
+ * This class is used to render Vue components inside the editor.
+ */
+declare class VueRenderer {
+    renderedComponent: RenderedComponent;
+    editor: Editor;
+    component: Component;
+    el: Element | null;
+    props: Record<string, any>;
+    constructor(component: Component, { props, editor }: VueRendererOptions);
+    get element(): Element | null;
+    get ref(): any;
+    renderComponent(): {
+        vNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>;
+        destroy: () => void;
+        el: Element | null;
+    };
+    updateProps(props?: Record<string, any>): void;
+    destroy(): void;
+}
+
+export { BubbleMenu, Editor, EditorContent, FloatingMenu, NodeViewContent, NodeViewWrapper, VueNodeViewRenderer, type VueNodeViewRendererOptions, VueRenderer, type VueRendererOptions, nodeViewProps, useEditor };