@tiptap/core 2.0.0-beta.209 → 2.0.0-beta.210

package/src/inputRules/wrappingInputRule.ts

@@ -1,5 +1,5 @@
-import { Node as ProseMirrorNode, NodeType } from 'prosemirror-model'
-import { canJoin, findWrapping } from 'prosemirror-transform'
+import { Node as ProseMirrorNode, NodeType } from '@tiptap/pm/model'
+import { canJoin, findWrapping } from '@tiptap/pm/transform'
 
 import { InputRule, InputRuleFinder } from '../InputRule'
 import { ExtendedRegExpMatchArray } from '../types'
@@ -20,15 +20,14 @@ import { callOrReturn } from '../utilities/callOrReturn'
  * return a boolean to indicate whether a join should happen.
  */
 export function wrappingInputRule(config: {
-  find: InputRuleFinder,
-  type: NodeType,
+  find: InputRuleFinder
+  type: NodeType
   getAttributes?:
     | Record<string, any>
     | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
     | false
     | null
-  ,
-  joinPredicate?: (match: ExtendedRegExpMatchArray, node: ProseMirrorNode) => boolean,
+  joinPredicate?: (match: ExtendedRegExpMatchArray, node: ProseMirrorNode) => boolean
 }) {
   return new InputRule({
     find: config.find,

package/src/pasteRules/markPasteRule.ts

@@ -1,4 +1,4 @@
-import { MarkType } from 'prosemirror-model'
+import { MarkType } from '@tiptap/pm/model'
 
 import { getMarksBetween } from '../helpers/getMarksBetween'
 import { PasteRule, PasteRuleFinder } from '../PasteRule'
@@ -10,14 +10,13 @@ import { callOrReturn } from '../utilities/callOrReturn'
  * matched text is pasted into it.
  */
 export function markPasteRule(config: {
-  find: PasteRuleFinder,
-  type: MarkType,
+  find: PasteRuleFinder
+  type: MarkType
   getAttributes?:
     | Record<string, any>
     | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
     | false
     | null
-  ,
 }) {
   return new PasteRule({
     find: config.find,

package/src/pasteRules/nodePasteRule.ts

@@ -1,4 +1,4 @@
-import { NodeType } from 'prosemirror-model'
+import { NodeType } from '@tiptap/pm/model'
 
 import { PasteRule } from '../PasteRule'
 import { ExtendedRegExpMatchArray } from '../types'
@@ -9,13 +9,13 @@ import { callOrReturn } from '../utilities'
  * matched text is pasted into it.
  */
 export function nodePasteRule(config: {
-  find: RegExp,
-  type: NodeType,
+  find: RegExp
+  type: NodeType
   getAttributes?:
     | Record<string, any>
     | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
     | false
-    | null,
+    | null
 }) {
   return new PasteRule({
     find: config.find,
@@ -27,12 +27,10 @@ export function nodePasteRule(config: {
       }
 
       if (match.input) {
-        chain()
-          .deleteRange(range)
-          .insertContentAt(range.from, {
-            type: config.type.name,
-            attrs: attributes,
-          })
+        chain().deleteRange(range).insertContentAt(range.from, {
+          type: config.type.name,
+          attrs: attributes,
+        })
       }
     },
   })

package/src/types.ts

@@ -1,21 +1,11 @@
+import { Mark as ProseMirrorMark, Node as ProseMirrorNode, ParseOptions } from '@tiptap/pm/model'
+import { EditorState, Transaction } from '@tiptap/pm/state'
 import {
-  Mark as ProseMirrorMark,
-  Node as ProseMirrorNode,
-  ParseOptions,
-} from 'prosemirror-model'
-import { EditorState, Transaction } from 'prosemirror-state'
-import {
-  Decoration,
-  EditorProps,
-  EditorView,
-  NodeView,
-} from 'prosemirror-view'
+  Decoration, EditorProps, EditorView, NodeView,
+} from '@tiptap/pm/view'
 
 import {
-  Commands,
-  ExtensionConfig,
-  MarkConfig,
-  NodeConfig,
+  Commands, ExtensionConfig, MarkConfig, NodeConfig,
 } from '.'
 import { Editor } from './Editor'
 import { Extension } from './Extension'
@@ -32,89 +22,80 @@ export type ParentConfig<T> = Partial<{
     : T[P]
 }>
 
-export type Primitive =
-  | null
-  | undefined
-  | string
-  | number
-  | boolean
-  | symbol
-  | bigint
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint
 
 export type RemoveThis<T> = T extends (...args: any) => any
   ? (...args: Parameters<T>) => ReturnType<T>
   : T
 
-export type MaybeReturnType<T> = T extends (...args: any) => any
-  ? ReturnType<T>
-  : T
+export type MaybeReturnType<T> = T extends (...args: any) => any ? ReturnType<T> : T
 
 export type MaybeThisParameterType<T> = Exclude<T, Primitive> extends (...args: any) => any
   ? ThisParameterType<Exclude<T, Primitive>>
   : any
 
 export interface EditorEvents {
-  beforeCreate: { editor: Editor },
-  create: { editor: Editor },
-  update: { editor: Editor, transaction: Transaction },
-  selectionUpdate: { editor: Editor, transaction: Transaction },
-  transaction: { editor: Editor, transaction: Transaction },
-  focus: { editor: Editor, event: FocusEvent, transaction: Transaction },
-  blur: { editor: Editor, event: FocusEvent, transaction: Transaction },
-  destroy: void,
+  beforeCreate: { editor: Editor }
+  create: { editor: Editor }
+  update: { editor: Editor; transaction: Transaction }
+  selectionUpdate: { editor: Editor; transaction: Transaction }
+  transaction: { editor: Editor; transaction: Transaction }
+  focus: { editor: Editor; event: FocusEvent; transaction: Transaction }
+  blur: { editor: Editor; event: FocusEvent; transaction: Transaction }
+  destroy: void
 }
 
 export type EnableRules = (AnyExtension | string)[] | boolean
 
 export interface EditorOptions {
-  element: Element,
-  content: Content,
-  extensions: Extensions,
-  injectCSS: boolean,
-  injectNonce: string | undefined,
-  autofocus: FocusPosition,
-  editable: boolean,
-  editorProps: EditorProps,
-  parseOptions: ParseOptions,
-  enableInputRules: EnableRules,
-  enablePasteRules: EnableRules,
-  enableCoreExtensions: boolean,
-  onBeforeCreate: (props: EditorEvents['beforeCreate']) => void,
-  onCreate: (props: EditorEvents['create']) => void,
-  onUpdate: (props: EditorEvents['update']) => void,
-  onSelectionUpdate: (props: EditorEvents['selectionUpdate']) => void,
-  onTransaction: (props: EditorEvents['transaction']) => void,
-  onFocus: (props: EditorEvents['focus']) => void,
-  onBlur: (props: EditorEvents['blur']) => void,
-  onDestroy: (props: EditorEvents['destroy']) => void,
+  element: Element
+  content: Content
+  extensions: Extensions
+  injectCSS: boolean
+  injectNonce: string | undefined
+  autofocus: FocusPosition
+  editable: boolean
+  editorProps: EditorProps
+  parseOptions: ParseOptions
+  enableInputRules: EnableRules
+  enablePasteRules: EnableRules
+  enableCoreExtensions: boolean
+  onBeforeCreate: (props: EditorEvents['beforeCreate']) => void
+  onCreate: (props: EditorEvents['create']) => void
+  onUpdate: (props: EditorEvents['update']) => void
+  onSelectionUpdate: (props: EditorEvents['selectionUpdate']) => void
+  onTransaction: (props: EditorEvents['transaction']) => void
+  onFocus: (props: EditorEvents['focus']) => void
+  onBlur: (props: EditorEvents['blur']) => void
+  onDestroy: (props: EditorEvents['destroy']) => void
 }
 
 export type HTMLContent = string
 
 export type JSONContent = {
-  type?: string,
-  attrs?: Record<string, any>,
-  content?: JSONContent[],
+  type?: string
+  attrs?: Record<string, any>
+  content?: JSONContent[]
   marks?: {
-    type: string,
-    attrs?: Record<string, any>,
-    [key: string]: any,
-  }[],
-  text?: string,
-  [key: string]: any,
+    type: string
+    attrs?: Record<string, any>
+    [key: string]: any
+  }[]
+  text?: string
+  [key: string]: any
 }
 
 export type Content = HTMLContent | JSONContent | JSONContent[] | null
 
 export type CommandProps = {
-  editor: Editor,
-  tr: Transaction,
-  commands: SingleCommands,
-  can: () => CanCommands,
-  chain: () => ChainedCommands,
-  state: EditorState,
-  view: EditorView,
-  dispatch: ((args?: any) => any) | undefined,
+  editor: Editor
+  tr: Transaction
+  commands: SingleCommands
+  can: () => CanCommands
+  chain: () => ChainedCommands
+  state: EditorState
+  view: EditorView
+  dispatch: ((args?: any) => any) | undefined
 }
 
 export type Command = (props: CommandProps) => boolean
@@ -124,80 +105,83 @@ export type CommandSpec = (...args: any[]) => Command
 export type KeyboardShortcutCommand = (props: { editor: Editor }) => boolean
 
 export type Attribute = {
-  default: any,
-  rendered?: boolean,
-  renderHTML?: ((attributes: Record<string, any>) => Record<string, any> | null) | null,
-  parseHTML?: ((element: HTMLElement) => any | null) | null,
-  keepOnSplit: boolean,
-  isRequired?: boolean,
+  default: any
+  rendered?: boolean
+  renderHTML?: ((attributes: Record<string, any>) => Record<string, any> | null) | null
+  parseHTML?: ((element: HTMLElement) => any | null) | null
+  keepOnSplit: boolean
+  isRequired?: boolean
 }
 
 export type Attributes = {
-  [key: string]: Attribute,
+  [key: string]: Attribute
 }
 
 export type ExtensionAttribute = {
-  type: string,
-  name: string,
-  attribute: Required<Attribute>,
+  type: string
+  name: string
+  attribute: Required<Attribute>
 }
 
 export type GlobalAttributes = {
-  types: string[],
+  types: string[]
   attributes: {
     [key: string]: Attribute
-  },
+  }
 }[]
 
 export type PickValue<T, K extends keyof T> = T[K]
 
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void)
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
   ? I
   : never
 
-export type Diff<T extends keyof any, U extends keyof any> =
-  ({ [P in T]: P } & { [P in U]: never } & { [x: string]: never })[T]
+export type Diff<T extends keyof any, U extends keyof any> = ({ [P in T]: P } & {
+  [P in U]: never
+} & { [x: string]: never })[T]
 
 export type Overwrite<T, U> = Pick<T, Diff<keyof T, keyof U>> & U
 
 export type ValuesOf<T> = T[keyof T]
 
-export type KeysWithTypeOf<T, Type> = ({ [P in keyof T]: T[P] extends Type ? P : never })[keyof T]
+export type KeysWithTypeOf<T, Type> = { [P in keyof T]: T[P] extends Type ? P : never }[keyof T]
 
 export type NodeViewProps = {
-  editor: Editor,
-  node: ProseMirrorNode,
-  decorations: Decoration[],
-  selected: boolean,
-  extension: Node,
-  getPos: () => number,
-  updateAttributes: (attributes: Record<string, any>) => void,
-  deleteNode: () => void,
+  editor: Editor
+  node: ProseMirrorNode
+  decorations: Decoration[]
+  selected: boolean
+  extension: Node
+  getPos: () => number
+  updateAttributes: (attributes: Record<string, any>) => void
+  deleteNode: () => void
 }
 
 export interface NodeViewRendererOptions {
-  stopEvent: ((props: {
-    event: Event
-  }) => boolean) | null,
-  ignoreMutation: ((props: {
-    mutation: MutationRecord | { type: 'selection', target: Element }
-  }) => boolean) | null,
+  stopEvent: ((props: { event: Event }) => boolean) | null
+  ignoreMutation:
+    | ((props: { mutation: MutationRecord | { type: 'selection'; target: Element } }) => boolean)
+    | null
 }
 
 export type NodeViewRendererProps = {
-  editor: Editor,
-  node: ProseMirrorNode,
-  getPos: (() => number) | boolean,
-  HTMLAttributes: Record<string, any>,
-  decorations: Decoration[],
-  extension: Node,
+  editor: Editor
+  node: ProseMirrorNode
+  getPos: (() => number) | boolean
+  HTMLAttributes: Record<string, any>
+  decorations: Decoration[]
+  extension: Node
 }
 
-export type NodeViewRenderer = (props: NodeViewRendererProps) => (NodeView | {})
+export type NodeViewRenderer = (props: NodeViewRendererProps) => NodeView | {}
 
 export type AnyCommands = Record<string, (...args: any[]) => Command>
 
-export type UnionCommands<T = Command> = UnionToIntersection<ValuesOf<Pick<Commands<T>, KeysWithTypeOf<Commands<T>, {}>>>>
+export type UnionCommands<T = Command> = UnionToIntersection<
+  ValuesOf<Pick<Commands<T>, KeysWithTypeOf<Commands<T>, {}>>>
+>
 
 export type RawCommands = {
   [Item in keyof UnionCommands]: UnionCommands<Command>[Item]
@@ -218,39 +202,39 @@ export type CanCommands = SingleCommands & { chain: () => ChainedCommands }
 export type FocusPosition = 'start' | 'end' | 'all' | number | boolean | null
 
 export type Range = {
-  from: number,
-  to: number,
+  from: number
+  to: number
 }
 
 export type NodeRange = {
-  node: ProseMirrorNode,
-  from: number,
-  to: number,
+  node: ProseMirrorNode
+  from: number
+  to: number
 }
 
 export type MarkRange = {
-  mark: ProseMirrorMark,
-  from: number,
-  to: number,
+  mark: ProseMirrorMark
+  from: number
+  to: number
 }
 
 export type Predicate = (node: ProseMirrorNode) => boolean
 
 export type NodeWithPos = {
-  node: ProseMirrorNode,
-  pos: number,
+  node: ProseMirrorNode
+  pos: number
 }
 
 export type TextSerializer = (props: {
-  node: ProseMirrorNode,
-  pos: number,
-  parent: ProseMirrorNode,
-  index: number,
-  range: Range,
+  node: ProseMirrorNode
+  pos: number
+  parent: ProseMirrorNode
+  index: number
+  range: Range
 }) => string
 
 export type ExtendedRegExpMatchArray = RegExpMatchArray & {
-  data?: Record<string, any>,
+  data?: Record<string, any>
 }
 
 export type Dispatch = ((args?: any) => any) | undefined

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

@@ -1,20 +0,0 @@
-import { EditorState, Transaction } from 'prosemirror-state';
-import { Editor } from './Editor';
-import { AnyCommands, CanCommands, ChainedCommands, CommandProps, SingleCommands } from './types';
-export declare class CommandManager {
-    editor: Editor;
-    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;
-}

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

@@ -1,147 +0,0 @@
-import { MarkType, NodeType, Schema } from 'prosemirror-model';
-import { EditorState, Plugin, PluginKey, Transaction } from 'prosemirror-state';
-import { EditorView } from 'prosemirror-view';
-import { EventEmitter } from './EventEmitter';
-import { ExtensionManager } from './ExtensionManager';
-import * as extensions from './extensions';
-import { CanCommands, ChainedCommands, EditorEvents, EditorOptions, JSONContent, SingleCommands, TextSerializer } from './types';
-export { extensions };
-export interface HTMLElement {
-    editor?: Editor;
-}
-export declare class Editor extends EventEmitter<EditorEvents> {
-    private commandManager;
-    extensionManager: ExtensionManager;
-    private css;
-    schema: Schema;
-    view: EditorView;
-    isFocused: boolean;
-    extensionStorage: Record<string, any>;
-    options: EditorOptions;
-    constructor(options?: Partial<EditorOptions>);
-    /**
-     * Returns the editor storage.
-     */
-    get storage(): Record<string, any>;
-    /**
-     * An object of all registered commands.
-     */
-    get commands(): SingleCommands;
-    /**
-     * Create a command chain to call multiple commands at once.
-     */
-    chain(): ChainedCommands;
-    /**
-     * Check if a command or a command chain can be executed. Without executing it.
-     */
-    can(): CanCommands;
-    /**
-     * Inject CSS styles.
-     */
-    private injectCSS;
-    /**
-     * Update editor options.
-     *
-     * @param options A list of options
-     */
-    setOptions(options?: Partial<EditorOptions>): void;
-    /**
-     * Update editable state of the editor.
-     */
-    setEditable(editable: boolean): void;
-    /**
-     * Returns whether the editor is editable.
-     */
-    get isEditable(): boolean;
-    /**
-     * Returns the editor state.
-     */
-    get state(): EditorState;
-    /**
-     * Register a ProseMirror plugin.
-     *
-     * @param plugin A ProseMirror plugin
-     * @param handlePlugins Control how to merge the plugin into the existing plugins.
-     */
-    registerPlugin(plugin: Plugin, handlePlugins?: (newPlugin: Plugin, plugins: Plugin[]) => Plugin[]): void;
-    /**
-     * Unregister a ProseMirror plugin.
-     *
-     * @param nameOrPluginKey The plugins name
-     */
-    unregisterPlugin(nameOrPluginKey: string | PluginKey): void;
-    /**
-     * Creates an extension manager.
-     */
-    private createExtensionManager;
-    /**
-     * Creates an command manager.
-     */
-    private createCommandManager;
-    /**
-     * Creates a ProseMirror schema.
-     */
-    private createSchema;
-    /**
-     * Creates a ProseMirror view.
-     */
-    private createView;
-    /**
-     * Creates all node views.
-     */
-    createNodeViews(): void;
-    isCapturingTransaction: boolean;
-    private capturedTransaction;
-    captureTransaction(fn: Function): Transaction | null;
-    /**
-     * The callback over which to send transactions (state updates) produced by the view.
-     *
-     * @param transaction An editor state transaction
-     */
-    private dispatchTransaction;
-    /**
-     * Get attributes of the currently selected node or mark.
-     */
-    getAttributes(nameOrType: string | NodeType | MarkType): Record<string, any>;
-    /**
-     * Returns if the currently selected node or mark is active.
-     *
-     * @param name Name of the node or mark
-     * @param attributes Attributes of the node or mark
-     */
-    isActive(name: string, attributes?: {}): boolean;
-    isActive(attributes: {}): boolean;
-    /**
-     * Get the document as JSON.
-     */
-    getJSON(): JSONContent;
-    /**
-     * Get the document as HTML.
-     */
-    getHTML(): string;
-    /**
-     * Get the document as text.
-     */
-    getText(options?: {
-        blockSeparator?: string;
-        textSerializers?: Record<string, TextSerializer>;
-    }): string;
-    /**
-     * Check if there is no content.
-     */
-    get isEmpty(): boolean;
-    /**
-     * Get the number of characters for the current document.
-     *
-     * @deprecated
-     */
-    getCharacterCount(): number;
-    /**
-     * Destroy the editor.
-     */
-    destroy(): void;
-    /**
-     * Check if the editor is already destroyed.
-     */
-    get isDestroyed(): boolean;
-}

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

@@ -1,11 +0,0 @@
-declare type StringKeyOf<T> = Extract<keyof T, string>;
-declare type CallbackType<T extends Record<string, any>, EventName extends StringKeyOf<T>> = T[EventName] extends any[] ? T[EventName] : [T[EventName]];
-declare type CallbackFunction<T extends Record<string, any>, EventName extends StringKeyOf<T>> = (...props: CallbackType<T, EventName>) => any;
-export declare class EventEmitter<T extends Record<string, any>> {
-    private callbacks;
-    on<EventName extends StringKeyOf<T>>(event: EventName, fn: CallbackFunction<T, EventName>): this;
-    protected emit<EventName extends StringKeyOf<T>>(event: EventName, ...args: CallbackType<T, EventName>): this;
-    off<EventName extends StringKeyOf<T>>(event: EventName, fn?: CallbackFunction<T, EventName>): this;
-    protected removeAllListeners(): void;
-}
-export {};