@tiptap/core 2.0.0-beta.17 → 2.0.0-beta.170

package/src/types.ts

@@ -14,9 +14,56 @@ import { Extension } from './Extension'
 import { Node } from './Node'
 import { Mark } from './Mark'
 import { Editor } from './Editor'
-import { Commands } from '.'
+import {
+  Commands,
+  ExtensionConfig,
+  NodeConfig,
+  MarkConfig,
+} from '.'
+
+export type AnyConfig = ExtensionConfig | NodeConfig | MarkConfig
+export type AnyExtension = Extension | Node | Mark
+export type Extensions = AnyExtension[]
+
+export type ParentConfig<T> = Partial<{
+  [P in keyof T]: Required<T>[P] extends (...args: any) => any
+    ? (...args: Parameters<Required<T>[P]>) => ReturnType<Required<T>[P]>
+    : T[P]
+}>
+
+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 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,
+}
 
-export type Extensions = (Extension | Node | Mark)[]
+export type EnableRules = (AnyExtension | string)[] | boolean
 
 export interface EditorOptions {
   element: Element,
@@ -27,20 +74,35 @@ export interface EditorOptions {
   editable: boolean,
   editorProps: EditorProps,
   parseOptions: ParseOptions,
-  enableInputRules: boolean,
-  enablePasteRules: boolean,
-  onCreate: (props: { editor: Editor }) => void,
-  onUpdate: (props: { editor: Editor }) => void,
-  onViewUpdate: (props: { editor: Editor }) => void,
-  onSelectionUpdate: (props: { editor: Editor }) => void,
-  onTransaction: (props: { editor: Editor, transaction: Transaction }) => void,
-  onFocus: (props: { editor: Editor, event: FocusEvent }) => void,
-  onBlur: (props: { editor: Editor, event: FocusEvent }) => void,
-  onResize: (props: { editor: Editor }) => void,
-  onDestroy: () => void,
+  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 Content = string | JSON | null
+export type HTMLContent = string
+
+export type JSONContent = {
+  type?: string,
+  attrs?: Record<string, any>,
+  content?: JSONContent[],
+  marks?: {
+    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,
@@ -57,11 +119,13 @@ export type Command = (props: CommandProps) => boolean
 
 export type CommandSpec = (...args: any[]) => Command
 
+export type KeyboardShortcutCommand = (props: { editor: Editor }) => boolean
+
 export type Attribute = {
   default: any,
   rendered?: boolean,
-  renderHTML?: ((attributes: { [key: string]: any }) => { [key: string]: any } | null) | null,
-  parseHTML?: ((element: HTMLElement) => { [key: string]: any } | null) | null,
+  renderHTML?: ((attributes: Record<string, any>) => Record<string, any> | null) | null,
+  parseHTML?: ((element: HTMLElement) => any | null) | null,
   keepOnSplit: boolean,
 }
 
@@ -84,22 +148,18 @@ export type GlobalAttributes = {
 
 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 Overwrite<T, U> = Pick<T, Diff<keyof T, keyof U>> & U;
+export type Overwrite<T, U> = Pick<T, Diff<keyof T, keyof U>> & U
 
-export type AnyObject = {
-  [key: string]: any
-}
-
-export type ValuesOf<T> = T[keyof T];
+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,
@@ -108,45 +168,51 @@ export type NodeViewProps = {
   selected: boolean,
   extension: Node,
   getPos: () => number,
-  updateAttributes: (attributes: AnyObject) => void,
+  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,
 }
 
 export type NodeViewRendererProps = {
   editor: Editor,
   node: ProseMirrorNode,
   getPos: (() => number) | boolean,
-  HTMLAttributes: { [key: string]: any },
+  HTMLAttributes: Record<string, any>,
   decorations: Decoration[],
   extension: Node,
 }
 
 export type NodeViewRenderer = (props: NodeViewRendererProps) => (NodeView | {})
 
-export type UnionCommands = UnionToIntersection<ValuesOf<Pick<Commands, KeysWithTypeOf<Commands, {}>>>>
+export type AnyCommands = Record<string, (...args: any[]) => Command>
+
+export type UnionCommands<T = Command> = UnionToIntersection<ValuesOf<Pick<Commands<T>, KeysWithTypeOf<Commands<T>, {}>>>>
 
 export type RawCommands = {
-  [Item in keyof UnionCommands]: UnionCommands[Item] extends (...args: any[]) => any
-  ? (...args: Parameters<UnionCommands[Item]>) => Command
-  : never
+  [Item in keyof UnionCommands]: UnionCommands<Command>[Item]
 }
 
 export type SingleCommands = {
-  [Item in keyof RawCommands]: RawCommands[Item] extends (...args: any[]) => any
-  ? (...args: Parameters<RawCommands[Item]>) => boolean
-  : never
+  [Item in keyof UnionCommands]: UnionCommands<boolean>[Item]
 }
 
 export type ChainedCommands = {
-  [Item in keyof RawCommands]: RawCommands[Item] extends (...args: any[]) => any
-  ? (...args: Parameters<RawCommands[Item]>) => ChainedCommands
-  : never
+  [Item in keyof UnionCommands]: UnionCommands<ChainedCommands>[Item]
 } & {
   run: () => boolean
 }
 
 export type CanCommands = SingleCommands & { chain: () => ChainedCommands }
 
-export type FocusPosition = 'start' | 'end' | number | boolean | null
+export type FocusPosition = 'start' | 'end' | 'all' | number | boolean | null
 
 export type Range = {
   from: number,
@@ -166,3 +232,19 @@ export type MarkRange = {
 }
 
 export type Predicate = (node: ProseMirrorNode) => boolean
+
+export type NodeWithPos = {
+  node: ProseMirrorNode,
+  pos: number,
+}
+
+export type TextSerializer = (props: {
+  node: ProseMirrorNode,
+  pos: number,
+  parent: ProseMirrorNode,
+  index: number,
+}) => string
+
+export type ExtendedRegExpMatchArray = RegExpMatchArray & {
+  data?: Record<string, any>,
+}

package/src/utilities/callOrReturn.ts

@@ -1,3 +1,6 @@
+import { MaybeReturnType } from '../types'
+import { isFunction } from './isFunction'
+
 /**
  * Optionally calls `value` as a function.
  * Otherwise it is returned directly.
@@ -5,8 +8,8 @@
  * @param context Optional context to bind to function.
  * @param props Optional props to pass to function.
  */
-export default function callOrReturn(value: any, context: any = undefined, ...props: any[]): any {
-  if (typeof value === 'function') {
+export function callOrReturn<T>(value: T, context: any = undefined, ...props: any[]): MaybeReturnType<T> {
+  if (isFunction(value)) {
     if (context) {
       return value.bind(context)(...props)
     }
@@ -14,5 +17,5 @@ export default function callOrReturn(value: any, context: any = undefined, ...pr
     return value(...props)
   }
 
-  return value
+  return value as MaybeReturnType<T>
 }

package/src/utilities/createStyleTag.ts

@@ -1,6 +1,13 @@
-export default function createStyleTag(style: string): HTMLStyleElement {
+export function createStyleTag(style: string): HTMLStyleElement {
+  const tipTapStyleTag = (<HTMLStyleElement>document.querySelector('style[data-tiptap-style]'))
+
+  if (tipTapStyleTag !== null) {
+    return tipTapStyleTag
+  }
+
   const styleNode = document.createElement('style')
 
+  styleNode.setAttribute('data-tiptap-style', '')
   styleNode.innerHTML = style
   document.getElementsByTagName('head')[0].appendChild(styleNode)
 

package/src/utilities/deleteProps.ts

@@ -1,18 +1,16 @@
-import { AnyObject } from '../types'
-
 /**
  * Remove a property or an array of properties from an object
  * @param obj Object
  * @param key Key to remove
  */
-export default function deleteProps(obj: AnyObject, propOrProps: string | string[]): AnyObject {
+export function deleteProps(obj: Record<string, any>, propOrProps: string | string[]): Record<string, any> {
   const props = typeof propOrProps === 'string'
     ? [propOrProps]
     : propOrProps
 
   return Object
     .keys(obj)
-    .reduce((newObj: AnyObject, prop) => {
+    .reduce((newObj: Record<string, any>, prop) => {
       if (!props.includes(prop)) {
         newObj[prop] = obj[prop]
       }

package/src/utilities/elementFromString.ts

@@ -1,7 +1,6 @@
-export default function elementFromString(value: string): HTMLElement {
-  const htmlString = `<div>${value}</div>`
-  const parser = new window.DOMParser()
-  const element = parser.parseFromString(htmlString, 'text/html').body
+export function elementFromString(value: string): HTMLElement {
+  // add a wrapper to preserve leading and trailing whitespace
+  const wrappedValue = `<body>${value}</body>`
 
-  return element
+  return new window.DOMParser().parseFromString(wrappedValue, 'text/html').body
 }

package/src/utilities/escapeForRegEx.ts

@@ -0,0 +1,4 @@
+// source: https://stackoverflow.com/a/6969486
+export function escapeForRegEx(string: string): string {
+  return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
+}

package/src/utilities/findDuplicates.ts

@@ -0,0 +1,5 @@
+export function findDuplicates(items: any[]): any[] {
+  const filtered = items.filter((el, index) => items.indexOf(el) !== index)
+
+  return [...new Set(filtered)]
+}

package/src/utilities/fromString.ts

@@ -1,9 +1,9 @@
-export default function fromString(value: any): any {
+export function fromString(value: any): any {
   if (typeof value !== 'string') {
     return value
   }
 
-  if (value.match(/^\d*(\.\d+)?$/)) {
+  if (value.match(/^[+-]?(?:\d*\.)?\d+$/)) {
     return Number(value)
   }
 

package/src/utilities/isClass.ts

@@ -1,5 +1,5 @@
-export default function isClass(item: any): boolean {
-  if (item.constructor?.toString().substring(0, 5) !== 'class') {
+export function isClass(value: any): boolean {
+  if (value.constructor?.toString().substring(0, 5) !== 'class') {
     return false
   }
 

package/src/utilities/isEmptyObject.ts

@@ -1,3 +1,3 @@
-export default function isEmptyObject(object = {}): boolean {
-  return Object.keys(object).length === 0 && object.constructor === Object
+export function isEmptyObject(value = {}): boolean {
+  return Object.keys(value).length === 0 && value.constructor === Object
 }

package/src/utilities/isFunction.ts

@@ -0,0 +1,3 @@
+export function isFunction(value: any): value is Function {
+  return typeof value === 'function'
+}

package/src/utilities/isMacOS.ts

@@ -0,0 +1,5 @@
+export function isMacOS(): boolean {
+  return typeof navigator !== 'undefined'
+    ? /Mac/.test(navigator.platform)
+    : false
+}

package/src/utilities/isNumber.ts

@@ -0,0 +1,3 @@
+export function isNumber(value: any): value is number {
+  return typeof value === 'number'
+}

package/src/utilities/isObject.ts

@@ -1,10 +1,10 @@
-import isClass from './isClass'
+import { isClass } from './isClass'
 
-export default function isObject(item: any): boolean {
+export function isObject(value: any): boolean {
   return (
-    item
-    && typeof item === 'object'
-    && !Array.isArray(item)
-    && !isClass(item)
+    value
+    && typeof value === 'object'
+    && !Array.isArray(value)
+    && !isClass(value)
   )
 }

package/src/utilities/isPlainObject.ts

@@ -1,10 +1,13 @@
 // see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
 
-function getType(payload: any): string {
-  return Object.prototype.toString.call(payload).slice(8, -1)
+function getType(value: any): string {
+  return Object.prototype.toString.call(value).slice(8, -1)
 }
 
-export default function isPlainObject(payload: any): payload is Record<string, any> {
-  if (getType(payload) !== 'Object') return false
-  return payload.constructor === Object && Object.getPrototypeOf(payload) === Object.prototype
+export function isPlainObject(value: any): value is Record<string, any> {
+  if (getType(value) !== 'Object') {
+    return false
+  }
+
+  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype
 }

package/src/utilities/isRegExp.ts

@@ -0,0 +1,3 @@
+export function isRegExp(value: any): value is RegExp {
+  return Object.prototype.toString.call(value) === '[object RegExp]'
+}

package/src/utilities/isString.ts

@@ -0,0 +1,3 @@
+export function isString(value: any): value is string {
+  return typeof value === 'string'
+}

package/src/utilities/isiOS.ts

@@ -0,0 +1,12 @@
+export function isiOS(): boolean {
+  return [
+    'iPad Simulator',
+    'iPhone Simulator',
+    'iPod Simulator',
+    'iPad',
+    'iPhone',
+    'iPod',
+  ].includes(navigator.platform)
+  // iPad on iOS 13 detection
+  || (navigator.userAgent.includes('Mac') && 'ontouchend' in document)
+}

package/src/utilities/mergeAttributes.ts

@@ -1,6 +1,4 @@
-import { AnyObject } from '../types'
-
-export default function mergeAttributes(...objects: AnyObject[]): AnyObject {
+export function mergeAttributes(...objects: Record<string, any>[]): Record<string, any> {
   return objects
     .filter(item => !!item)
     .reduce((items, item) => {
@@ -11,6 +9,7 @@ export default function mergeAttributes(...objects: AnyObject[]): AnyObject {
 
         if (!exists) {
           mergedAttributes[key] = value
+
           return
         }
 

package/src/utilities/mergeDeep.ts

@@ -1,7 +1,6 @@
-import { AnyObject } from '../types'
-import isPlainObject from './isPlainObject'
+import { isPlainObject } from './isPlainObject'
 
-export default function mergeDeep(target: AnyObject, source: AnyObject): AnyObject {
+export function mergeDeep(target: Record<string, any>, source: Record<string, any>): Record<string, any> {
   const output = { ...target }
 
   if (isPlainObject(target) && isPlainObject(source)) {

package/src/utilities/minMax.ts

@@ -1,3 +1,3 @@
-export default function minMax(value = 0, min = 0, max = 0): number {
+export function minMax(value = 0, min = 0, max = 0): number {
   return Math.min(Math.max(value, min), max)
 }

package/src/utilities/objectIncludes.ts

@@ -1,18 +1,30 @@
-import { AnyObject } from '../types'
+import { isRegExp } from './isRegExp'
 
 /**
  * Check if object1 includes object2
  * @param object1 Object
  * @param object2 Object
  */
-export default function objectIncludes(object1: AnyObject, object2: AnyObject): boolean {
+export function objectIncludes(
+  object1: Record<string, any>,
+  object2: Record<string, any>,
+  options: { strict: boolean } = { strict: true },
+): boolean {
   const keys = Object.keys(object2)
 
   if (!keys.length) {
     return true
   }
 
-  return !!keys
-    .filter(key => object2[key] === object1[key])
-    .length
+  return keys.every(key => {
+    if (options.strict) {
+      return object2[key] === object1[key]
+    }
+
+    if (isRegExp(object2[key])) {
+      return object2[key].test(object1[key])
+    }
+
+    return object2[key] === object1[key]
+  })
 }

package/src/utilities/removeDuplicates.ts

@@ -0,0 +1,15 @@
+/**
+ * Removes duplicated values within an array.
+ * Supports numbers, strings and objects.
+ */
+export function removeDuplicates<T>(array: T[], by = JSON.stringify): T[] {
+  const seen: Record<any, any> = {}
+
+  return array.filter(item => {
+    const key = by(item)
+
+    return Object.prototype.hasOwnProperty.call(seen, key)
+      ? false
+      : (seen[key] = true)
+  })
+}