@tiptap/vue-2 2.0.0-beta.57 → 2.0.0-beta.60

package/dist/packages/core/src/CommandManager.d.ts

@@ -3,11 +3,18 @@ import { Editor } from './Editor';
 import { SingleCommands, ChainedCommands, CanCommands, AnyCommands, CommandProps } from './types';
 export default class CommandManager {
     editor: Editor;
-    commands: AnyCommands;
-    constructor(editor: Editor, commands: AnyCommands);
-    createCommands(): SingleCommands;
+    rawCommands: AnyCommands;
+    customState?: EditorState;
+    constructor(props: {
+        editor: Editor;
+        state?: EditorState;
+    });
+    get hasCustomState(): boolean;
+    get state(): EditorState;
+    get commands(): SingleCommands;
+    get chain(): () => ChainedCommands;
+    get can(): () => CanCommands;
     createChain(startTr?: Transaction, shouldDispatch?: boolean): ChainedCommands;
     createCan(startTr?: Transaction): CanCommands;
     buildProps(tr: Transaction, shouldDispatch?: boolean): CommandProps;
-    chainableState(tr: Transaction, state: EditorState): EditorState;
 }

package/dist/packages/core/src/Extension.d.ts

@@ -1,5 +1,6 @@
 import { Plugin, Transaction } from 'prosemirror-state';
-import { InputRule } from 'prosemirror-inputrules';
+import { InputRule } from './InputRule';
+import { PasteRule } from './PasteRule';
 import { Editor } from './Editor';
 import { Node } from './Node';
 import { Mark } from './Mark';
@@ -65,7 +66,7 @@ declare module '@tiptap/core' {
             options: Options;
             editor: Editor;
             parent: ParentConfig<ExtensionConfig<Options>>['addPasteRules'];
-        }) => Plugin[];
+        }) => PasteRule[];
         /**
          * ProseMirror plugins
          */

package/dist/packages/core/src/InputRule.d.ts

@@ -0,0 +1,42 @@
+import { EditorState, Plugin } from 'prosemirror-state';
+import { Editor } from './Editor';
+import { Range, ExtendedRegExpMatchArray, SingleCommands, ChainedCommands, CanCommands } from './types';
+export declare type InputRuleMatch = {
+    index: number;
+    text: string;
+    replaceWith?: string;
+    match?: RegExpMatchArray;
+    data?: Record<string, any>;
+};
+export declare type InputRuleFinder = RegExp | ((text: string) => InputRuleMatch | null);
+export declare class InputRule {
+    find: InputRuleFinder;
+    handler: (props: {
+        state: EditorState;
+        range: Range;
+        match: ExtendedRegExpMatchArray;
+        commands: SingleCommands;
+        chain: () => ChainedCommands;
+        can: () => CanCommands;
+    }) => void;
+    constructor(config: {
+        find: InputRuleFinder;
+        handler: (props: {
+            state: EditorState;
+            range: Range;
+            match: ExtendedRegExpMatchArray;
+            commands: SingleCommands;
+            chain: () => ChainedCommands;
+            can: () => CanCommands;
+        }) => void;
+    });
+}
+/**
+ * Create an input rules plugin. When enabled, it will cause text
+ * input that matches any of the given rules to trigger the rule’s
+ * action.
+ */
+export declare function inputRulesPlugin(props: {
+    editor: Editor;
+    rules: InputRule[];
+}): Plugin;

package/dist/packages/core/src/Mark.d.ts

@@ -1,6 +1,7 @@
 import { DOMOutputSpec, MarkSpec, Mark as ProseMirrorMark, MarkType } from 'prosemirror-model';
 import { Plugin, Transaction } from 'prosemirror-state';
-import { InputRule } from 'prosemirror-inputrules';
+import { InputRule } from './InputRule';
+import { PasteRule } from './PasteRule';
 import { Extensions, Attributes, RawCommands, GlobalAttributes, ParentConfig, KeyboardShortcutCommand } from './types';
 import { Node } from './Node';
 import { MarkConfig } from '.';
@@ -69,7 +70,7 @@ declare module '@tiptap/core' {
             editor: Editor;
             type: MarkType;
             parent: ParentConfig<MarkConfig<Options>>['addPasteRules'];
-        }) => Plugin[];
+        }) => PasteRule[];
         /**
          * ProseMirror plugins
          */
@@ -226,6 +227,14 @@ declare module '@tiptap/core' {
             options: Options;
             parent: ParentConfig<MarkConfig<Options>>['spanning'];
         }) => MarkSpec['spanning']);
+        /**
+         * Code
+         */
+        code?: boolean | ((this: {
+            name: string;
+            options: Options;
+            parent: ParentConfig<MarkConfig<Options>>['code'];
+        }) => boolean);
         /**
          * Parse HTML
          */

package/dist/packages/core/src/Node.d.ts

@@ -1,6 +1,7 @@
 import { DOMOutputSpec, NodeSpec, Node as ProseMirrorNode, NodeType } from 'prosemirror-model';
 import { Plugin, Transaction } from 'prosemirror-state';
-import { InputRule } from 'prosemirror-inputrules';
+import { InputRule } from './InputRule';
+import { PasteRule } from './PasteRule';
 import { Extensions, Attributes, NodeViewRenderer, GlobalAttributes, RawCommands, ParentConfig, KeyboardShortcutCommand } from './types';
 import { NodeConfig } from '.';
 import { Editor } from './Editor';
@@ -68,7 +69,7 @@ declare module '@tiptap/core' {
             editor: Editor;
             type: NodeType;
             parent: ParentConfig<NodeConfig<Options>>['addPasteRules'];
-        }) => Plugin[];
+        }) => PasteRule[];
         /**
          * ProseMirror plugins
          */

package/dist/packages/core/src/PasteRule.d.ts

@@ -0,0 +1,42 @@
+import { EditorState, Plugin } from 'prosemirror-state';
+import { Editor } from './Editor';
+import { Range, ExtendedRegExpMatchArray, SingleCommands, ChainedCommands, CanCommands } from './types';
+export declare type PasteRuleMatch = {
+    index: number;
+    text: string;
+    replaceWith?: string;
+    match?: RegExpMatchArray;
+    data?: Record<string, any>;
+};
+export declare type PasteRuleFinder = RegExp | ((text: string) => PasteRuleMatch[] | null | undefined);
+export declare class PasteRule {
+    find: PasteRuleFinder;
+    handler: (props: {
+        state: EditorState;
+        range: Range;
+        match: ExtendedRegExpMatchArray;
+        commands: SingleCommands;
+        chain: () => ChainedCommands;
+        can: () => CanCommands;
+    }) => void;
+    constructor(config: {
+        find: PasteRuleFinder;
+        handler: (props: {
+            state: EditorState;
+            range: Range;
+            match: ExtendedRegExpMatchArray;
+            commands: SingleCommands;
+            chain: () => ChainedCommands;
+            can: () => CanCommands;
+        }) => void;
+    });
+}
+/**
+ * Create an paste rules plugin. When enabled, it will cause pasted
+ * text that matches any of the given rules to trigger the rule’s
+ * action.
+ */
+export declare function pasteRulesPlugin(props: {
+    editor: Editor;
+    rules: PasteRule[];
+}): Plugin;

package/dist/packages/core/src/commands/insertContent.d.ts

@@ -1,4 +1,4 @@
-import { CreateNodeFromContentOptions } from '../helpers/createNodeFromContent';
+import { ParseOptions } from 'prosemirror-model';
 import { RawCommands, Content } from '../types';
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -6,7 +6,10 @@ declare module '@tiptap/core' {
             /**
              * Insert a node or string of HTML at the current position.
              */
-            insertContent: (value: Content, options?: CreateNodeFromContentOptions) => ReturnType;
+            insertContent: (value: Content, options?: {
+                parseOptions?: ParseOptions;
+                updateSelection?: boolean;
+            }) => ReturnType;
         };
     }
 }

package/dist/packages/core/src/commands/insertContentAt.d.ts

@@ -1,4 +1,4 @@
-import { CreateNodeFromContentOptions } from '../helpers/createNodeFromContent';
+import { ParseOptions } from 'prosemirror-model';
 import { RawCommands, Content, Range } from '../types';
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -6,7 +6,10 @@ declare module '@tiptap/core' {
             /**
              * Insert a node or string of HTML at a specific position.
              */
-            insertContentAt: (position: number | Range, value: Content, options?: CreateNodeFromContentOptions) => ReturnType;
+            insertContentAt: (position: number | Range, value: Content, options?: {
+                parseOptions?: ParseOptions;
+                updateSelection?: boolean;
+            }) => ReturnType;
         };
     }
 }

package/dist/packages/core/src/helpers/createChainableState.d.ts

@@ -0,0 +1,5 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+export default function createChainableState(config: {
+    transaction: Transaction;
+    state: EditorState;
+}): EditorState;

package/dist/packages/core/src/index.d.ts

@@ -6,10 +6,17 @@ export * from './Node';
 export * from './Mark';
 export * from './NodeView';
 export * from './Tracker';
+export * from './InputRule';
+export * from './PasteRule';
+export * from './CommandManager';
 export * from './types';
 export { default as nodeInputRule } from './inputRules/nodeInputRule';
 export { default as markInputRule } from './inputRules/markInputRule';
+export { default as textblockTypeInputRule } from './inputRules/textblockTypeInputRule';
+export { default as textInputRule } from './inputRules/textInputRule';
+export { default as wrappingInputRule } from './inputRules/wrappingInputRule';
 export { default as markPasteRule } from './pasteRules/markPasteRule';
+export { default as textPasteRule } from './pasteRules/textPasteRule';
 export { default as callOrReturn } from './utilities/callOrReturn';
 export { default as mergeAttributes } from './utilities/mergeAttributes';
 export { default as getExtensionField } from './helpers/getExtensionField';

package/dist/packages/core/src/inputRules/markInputRule.d.ts

@@ -1,3 +1,12 @@
-import { InputRule } from 'prosemirror-inputrules';
+import { InputRule, InputRuleFinder } from '../InputRule';
 import { MarkType } from 'prosemirror-model';
-export default function (regexp: RegExp, markType: MarkType, getAttributes?: Function): InputRule;
+import { ExtendedRegExpMatchArray } from '../types';
+/**
+ * Build an input rule that adds a mark when the
+ * matched text is typed into it.
+ */
+export default function markInputRule(config: {
+    find: InputRuleFinder;
+    type: MarkType;
+    getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null;
+}): InputRule;

package/dist/packages/core/src/inputRules/nodeInputRule.d.ts

@@ -1,3 +1,12 @@
-import { InputRule } from 'prosemirror-inputrules';
 import { NodeType } from 'prosemirror-model';
-export default function (regexp: RegExp, type: NodeType, getAttributes?: (match: any) => any): InputRule;
+import { InputRule, InputRuleFinder } from '../InputRule';
+import { ExtendedRegExpMatchArray } from '../types';
+/**
+ * Build an input rule that adds a node when the
+ * matched text is typed into it.
+ */
+export default function nodeInputRule(config: {
+    find: InputRuleFinder;
+    type: NodeType;
+    getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null;
+}): InputRule;

package/dist/packages/core/src/inputRules/textInputRule.d.ts

@@ -0,0 +1,9 @@
+import { InputRule, InputRuleFinder } from '../InputRule';
+/**
+ * Build an input rule that replaces text when the
+ * matched text is typed into it.
+ */
+export default function textInputRule(config: {
+    find: InputRuleFinder;
+    replace: string;
+}): InputRule;

package/dist/packages/core/src/inputRules/textblockTypeInputRule.d.ts

@@ -0,0 +1,14 @@
+import { InputRule, InputRuleFinder } from '../InputRule';
+import { NodeType } from 'prosemirror-model';
+import { ExtendedRegExpMatchArray } from '../types';
+/**
+ * Build an input rule that changes the type of a textblock when the
+ * matched text is typed into it. When using a regular expresion you’ll
+ * probably want the regexp to start with `^`, so that the pattern can
+ * only occur at the start of a textblock.
+ */
+export default function textblockTypeInputRule(config: {
+    find: InputRuleFinder;
+    type: NodeType;
+    getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null;
+}): InputRule;

package/dist/packages/core/src/inputRules/wrappingInputRule.d.ts

@@ -0,0 +1,23 @@
+import { InputRule, InputRuleFinder } from '../InputRule';
+import { NodeType, Node as ProseMirrorNode } from 'prosemirror-model';
+import { ExtendedRegExpMatchArray } from '../types';
+/**
+ * Build an input rule for automatically wrapping a textblock when a
+ * given string is typed. When using a regular expresion you’ll
+ * probably want the regexp to start with `^`, so that the pattern can
+ * only occur at the start of a textblock.
+ *
+ * `type` is the type of node to wrap in.
+ *
+ * By default, if there’s a node with the same type above the newly
+ * wrapped node, the rule will try to join those
+ * two nodes. You can pass a join predicate, which takes a regular
+ * expression match and the node before the wrapped node, and can
+ * return a boolean to indicate whether a join should happen.
+ */
+export default function wrappingInputRule(config: {
+    find: InputRuleFinder;
+    type: NodeType;
+    getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null;
+    joinPredicate?: (match: ExtendedRegExpMatchArray, node: ProseMirrorNode) => boolean;
+}): InputRule;

package/dist/packages/core/src/pasteRules/markPasteRule.d.ts

@@ -1,3 +1,12 @@
-import { Plugin } from 'prosemirror-state';
+import { PasteRule, PasteRuleFinder } from '../PasteRule';
 import { MarkType } from 'prosemirror-model';
-export default function (regexp: RegExp, type: MarkType, getAttributes?: Record<string, any> | ((match: RegExpExecArray) => Record<string, any>) | false | null): Plugin;
+import { ExtendedRegExpMatchArray } from '../types';
+/**
+ * Build an paste rule that adds a mark when the
+ * matched text is pasted into it.
+ */
+export default function markPasteRule(config: {
+    find: PasteRuleFinder;
+    type: MarkType;
+    getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null;
+}): PasteRule;

package/dist/packages/core/src/pasteRules/textPasteRule.d.ts

@@ -0,0 +1,9 @@
+import { PasteRule, PasteRuleFinder } from '../PasteRule';
+/**
+ * Build an paste rule that replaces text when the
+ * matched text is pasted into it.
+ */
+export default function textPasteRule(config: {
+    find: PasteRuleFinder;
+    replace: string;
+}): PasteRule;

package/dist/packages/core/src/types.d.ts

@@ -202,3 +202,6 @@ export declare type TextSerializer = (props: {
     parent: ProseMirrorNode;
     index: number;
 }) => string;
+export declare type ExtendedRegExpMatchArray = RegExpMatchArray & {
+    data?: Record<string, any>;
+};

package/dist/packages/core/src/utilities/isClass.d.ts

@@ -1 +1 @@
-export default function isClass(item: any): boolean;
+export default function isClass(value: any): boolean;

package/dist/packages/core/src/utilities/isEmptyObject.d.ts

@@ -1 +1 @@
-export default function isEmptyObject(object?: {}): boolean;
+export default function isEmptyObject(value?: {}): boolean;

package/dist/packages/core/src/utilities/isFunction.d.ts

@@ -0,0 +1 @@
+export default function isObject(value: any): value is Function;

package/dist/packages/core/src/utilities/isObject.d.ts

@@ -1 +1 @@
-export default function isObject(item: any): boolean;
+export default function isObject(value: any): boolean;

package/dist/packages/core/src/utilities/isPlainObject.d.ts

@@ -1 +1 @@
-export default function isPlainObject(payload: any): payload is Record<string, any>;
+export default function isPlainObject(value: any): value is Record<string, any>;

package/dist/packages/core/src/utilities/isRegExp.d.ts

@@ -1 +1 @@
-export default function isRegExp(value: any): boolean;
+export default function isRegExp(value: any): value is RegExp;

package/dist/packages/core/src/utilities/isString.d.ts

@@ -0,0 +1 @@
+export default function isString(value: any): value is string;

package/dist/packages/extension-collaboration/src/helpers/isChangeOrigin.d.ts

@@ -0,0 +1,2 @@
+import { Transaction } from 'prosemirror-state';
+export declare function isChangeOrigin(transaction: Transaction): boolean;

package/dist/packages/extension-collaboration/src/index.d.ts

@@ -1,3 +1,4 @@
 import { Collaboration } from './collaboration';
 export * from './collaboration';
+export * from './helpers/isChangeOrigin';
 export default Collaboration;

package/dist/packages/extension-link/src/link.d.ts

@@ -37,12 +37,4 @@ declare module '@tiptap/core' {
         };
     }
 }
-/**
- * A regex that matches any string that contains a link
- */
-export declare const pasteRegex: RegExp;
-/**
- * A regex that matches an url
- */
-export declare const pasteRegexExact: RegExp;
 export declare const Link: Mark<LinkOptions>;

package/dist/packages/extension-placeholder/src/placeholder.d.ts

@@ -6,6 +6,7 @@ export interface PlaceholderOptions {
     placeholder: ((PlaceholderProps: {
         editor: Editor;
         node: ProsemirrorNode;
+        pos: number;
     }) => string) | string;
     showOnlyWhenEditable: boolean;
     showOnlyCurrent: boolean;

package/dist/packages/extension-typography/src/typography.d.ts

@@ -1,18 +1,23 @@
 import { Extension } from '@tiptap/core';
-import { InputRule } from 'prosemirror-inputrules';
-export declare const leftArrow: InputRule<any>;
-export declare const rightArrow: InputRule<any>;
-export declare const copyright: InputRule<any>;
-export declare const trademark: InputRule<any>;
-export declare const registeredTrademark: InputRule<any>;
-export declare const oneHalf: InputRule<any>;
-export declare const plusMinus: InputRule<any>;
-export declare const notEqual: InputRule<any>;
-export declare const laquo: InputRule<any>;
-export declare const raquo: InputRule<any>;
-export declare const multiplication: InputRule<any>;
-export declare const superscriptTwo: InputRule<any>;
-export declare const superscriptThree: InputRule<any>;
-export declare const oneQuarter: InputRule<any>;
-export declare const threeQuarters: InputRule<any>;
+export declare const emDash: import("@tiptap/core").InputRule;
+export declare const ellipsis: import("@tiptap/core").InputRule;
+export declare const openDoubleQuote: import("@tiptap/core").InputRule;
+export declare const closeDoubleQuote: import("@tiptap/core").InputRule;
+export declare const openSingleQuote: import("@tiptap/core").InputRule;
+export declare const closeSingleQuote: import("@tiptap/core").InputRule;
+export declare const leftArrow: import("@tiptap/core").InputRule;
+export declare const rightArrow: import("@tiptap/core").InputRule;
+export declare const copyright: import("@tiptap/core").InputRule;
+export declare const trademark: import("@tiptap/core").InputRule;
+export declare const registeredTrademark: import("@tiptap/core").InputRule;
+export declare const oneHalf: import("@tiptap/core").InputRule;
+export declare const plusMinus: import("@tiptap/core").InputRule;
+export declare const notEqual: import("@tiptap/core").InputRule;
+export declare const laquo: import("@tiptap/core").InputRule;
+export declare const raquo: import("@tiptap/core").InputRule;
+export declare const multiplication: import("@tiptap/core").InputRule;
+export declare const superscriptTwo: import("@tiptap/core").InputRule;
+export declare const superscriptThree: import("@tiptap/core").InputRule;
+export declare const oneQuarter: import("@tiptap/core").InputRule;
+export declare const threeQuarters: import("@tiptap/core").InputRule;
 export declare const Typography: Extension<unknown>;

package/dist/packages/react/src/ReactRenderer.d.ts

@@ -1,23 +1,24 @@
 import React from 'react';
-import { Editor } from './Editor';
+import { Editor } from '@tiptap/core';
+import { Editor as ExtendedEditor } from './Editor';
 export interface ReactRendererOptions {
     editor: Editor;
     props?: Record<string, any>;
     as?: string;
 }
-declare type ComponentType = React.ComponentClass | React.FunctionComponent | React.ForwardRefExoticComponent<{
+declare type ComponentType<R> = React.ComponentClass | React.FunctionComponent | React.ForwardRefExoticComponent<{
     items: any[];
     command: any;
-} & React.RefAttributes<unknown>>;
-export declare class ReactRenderer {
+} & React.RefAttributes<R>>;
+export declare class ReactRenderer<R = unknown> {
     id: string;
-    editor: Editor;
+    editor: ExtendedEditor;
     component: any;
     element: Element;
     props: Record<string, any>;
     reactElement: React.ReactNode;
-    ref: React.Component | null;
-    constructor(component: ComponentType, { editor, props, as }: ReactRendererOptions);
+    ref: R | null;
+    constructor(component: ComponentType<R>, { editor, props, as }: ReactRendererOptions);
     render(): void;
     updateProps(props?: Record<string, any>): void;
     destroy(): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiptap/vue-2",
   "description": "Vue components for tiptap",
-  "version": "2.0.0-beta.57",
+  "version": "2.0.0-beta.60",
   "homepage": "https://tiptap.dev",
   "keywords": [
     "tiptap",
@@ -28,14 +28,14 @@
     "vue": "^2.6.0"
   },
   "dependencies": {
-    "@tiptap/extension-bubble-menu": "^2.0.0-beta.39",
-    "@tiptap/extension-floating-menu": "^2.0.0-beta.33",
-    "prosemirror-view": "^1.20.1"
+    "@tiptap/extension-bubble-menu": "^2.0.0-beta.42",
+    "@tiptap/extension-floating-menu": "^2.0.0-beta.36",
+    "prosemirror-view": "^1.20.3"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/ueberdosis/tiptap",
     "directory": "packages/vue-2"
   },
-  "gitHead": "dc868b3d2a034abbd308da63057a6ae52c194b8d"
+  "gitHead": "9948e2499a3aa6ca72b677ef2ca96de1db1cb6b5"
 }