@portabletext/editor 0.0.0

package/src/utils/validateValue.ts

@@ -0,0 +1,394 @@
+import {
+  isPortableTextTextBlock,
+  type PortableTextBlock,
+  type PortableTextSpan,
+  type PortableTextTextBlock,
+} from '@sanity/types'
+import {flatten, isPlainObject, uniq} from 'lodash'
+
+import {insert, set, setIfMissing, unset} from '../patch/PatchEvent'
+import {type InvalidValueResolution, type PortableTextMemberSchemaTypes} from '../types/editor'
+import {EMPTY_MARKDEFS} from './values'
+
+export interface Validation {
+  valid: boolean
+  resolution: InvalidValueResolution | null
+  value: PortableTextBlock[] | undefined
+}
+
+export function validateValue(
+  value: PortableTextBlock[] | undefined,
+  types: PortableTextMemberSchemaTypes,
+  keyGenerator: () => string,
+): Validation {
+  let resolution: InvalidValueResolution | null = null
+  let valid = true
+  const validChildTypes = [types.span.name, ...types.inlineObjects.map((t) => t.name)]
+  const validBlockTypes = [types.block.name, ...types.blockObjects.map((t) => t.name)]
+
+  // Undefined is allowed
+  if (value === undefined) {
+    return {valid: true, resolution: null, value}
+  }
+  // Only lengthy arrays are allowed in the editor.
+  if (!Array.isArray(value) || value.length === 0) {
+    return {
+      valid: false,
+      resolution: {
+        patches: [unset([])],
+        description: 'Editor value must be an array of Portable Text blocks, or undefined.',
+        action: 'Unset the value',
+        item: value,
+
+        i18n: {
+          description: 'inputs.portable-text.invalid-value.not-an-array.description',
+          action: 'inputs.portable-text.invalid-value.not-an-array.action',
+        },
+      },
+      value,
+    }
+  }
+  if (
+    value.some((blk: PortableTextBlock, index: number): boolean => {
+      // Is the block an object?
+      if (!isPlainObject(blk)) {
+        resolution = {
+          patches: [unset([index])],
+          description: `Block must be an object, got ${String(blk)}`,
+          action: `Unset invalid item`,
+          item: blk,
+
+          i18n: {
+            description: 'inputs.portable-text.invalid-value.not-an-object.description',
+            action: 'inputs.portable-text.invalid-value.not-an-object.action',
+            values: {index},
+          },
+        }
+        return true
+      }
+      // Test that every block has a _key prop
+      if (!blk._key || typeof blk._key !== 'string') {
+        resolution = {
+          patches: [set({...blk, _key: keyGenerator()}, [index])],
+          description: `Block at index ${index} is missing required _key.`,
+          action: 'Set the block with a random _key value',
+          item: blk,
+
+          i18n: {
+            description: 'inputs.portable-text.invalid-value.missing-key.description',
+            action: 'inputs.portable-text.invalid-value.missing-key.action',
+            values: {index},
+          },
+        }
+        return true
+      }
+      // Test that every block has valid _type
+      if (!blk._type || !validBlockTypes.includes(blk._type)) {
+        // Special case where block type is set to default 'block', but the block type is named something else according to the schema.
+        if (blk._type === 'block') {
+          const currentBlockTypeName = types.block.name
+          resolution = {
+            patches: [set({...blk, _type: currentBlockTypeName}, [{_key: blk._key}])],
+            description: `Block with _key '${blk._key}' has invalid type name '${blk._type}'. According to the schema, the block type name is '${currentBlockTypeName}'`,
+            action: `Use type '${currentBlockTypeName}'`,
+            item: blk,
+
+            i18n: {
+              description: 'inputs.portable-text.invalid-value.incorrect-block-type.description',
+              action: 'inputs.portable-text.invalid-value.incorrect-block-type.action',
+              values: {key: blk._key, expectedTypeName: currentBlockTypeName},
+            },
+          }
+          return true
+        }
+
+        // If the block has no `_type`, but aside from that is a valid Portable Text block
+        if (!blk._type && isPortableTextTextBlock({...blk, _type: types.block.name})) {
+          resolution = {
+            patches: [set({...blk, _type: types.block.name}, [{_key: blk._key}])],
+            description: `Block with _key '${blk._key}' is missing a type name. According to the schema, the block type name is '${types.block.name}'`,
+            action: `Use type '${types.block.name}'`,
+            item: blk,
+
+            i18n: {
+              description: 'inputs.portable-text.invalid-value.missing-block-type.description',
+              action: 'inputs.portable-text.invalid-value.missing-block-type.action',
+              values: {key: blk._key, expectedTypeName: types.block.name},
+            },
+          }
+          return true
+        }
+
+        if (!blk._type) {
+          resolution = {
+            patches: [unset([{_key: blk._key}])],
+            description: `Block with _key '${blk._key}' is missing an _type property`,
+            action: 'Remove the block',
+            item: blk,
+
+            i18n: {
+              description: 'inputs.portable-text.invalid-value.missing-type.description',
+              action: 'inputs.portable-text.invalid-value.missing-type.action',
+              values: {key: blk._key},
+            },
+          }
+          return true
+        }
+
+        resolution = {
+          patches: [unset([{_key: blk._key}])],
+          description: `Block with _key '${blk._key}' has invalid _type '${blk._type}'`,
+          action: 'Remove the block',
+          item: blk,
+
+          i18n: {
+            description: 'inputs.portable-text.invalid-value.disallowed-type.description',
+            action: 'inputs.portable-text.invalid-value.disallowed-type.action',
+            values: {key: blk._key, typeName: blk._type},
+          },
+        }
+        return true
+      }
+
+      // Test regular text blocks
+      if (blk._type === types.block.name) {
+        const textBlock = blk as PortableTextTextBlock
+        // Test that it has a valid children property (array)
+        if (textBlock.children && !Array.isArray(textBlock.children)) {
+          resolution = {
+            patches: [set({children: []}, [{_key: textBlock._key}])],
+            description: `Text block with _key '${textBlock._key}' has a invalid required property 'children'.`,
+            action: 'Reset the children property',
+            item: textBlock,
+
+            i18n: {
+              description:
+                'inputs.portable-text.invalid-value.missing-or-invalid-children.description',
+              action: 'inputs.portable-text.invalid-value.missing-or-invalid-children.action',
+              values: {key: textBlock._key},
+            },
+          }
+          return true
+        }
+        // Test that children is set and lengthy
+        if (
+          textBlock.children === undefined ||
+          (Array.isArray(textBlock.children) && textBlock.children.length === 0)
+        ) {
+          const newSpan = {
+            _type: types.span.name,
+            _key: keyGenerator(),
+            text: '',
+            marks: [],
+          }
+          resolution = {
+            autoResolve: true,
+            patches: [
+              setIfMissing([], [{_key: blk._key}, 'children']),
+              insert([newSpan], 'after', [{_key: blk._key}, 'children', 0]),
+            ],
+            description: `Children for text block with _key '${blk._key}' is empty.`,
+            action: 'Insert an empty text',
+            item: blk,
+
+            i18n: {
+              description: 'inputs.portable-text.invalid-value.empty-children.description',
+              action: 'inputs.portable-text.invalid-value.empty-children.action',
+              values: {key: blk._key},
+            },
+          }
+          return true
+        }
+        // Test that markDefs are valid if they exists
+        if (blk.markDefs && !Array.isArray(blk.markDefs)) {
+          resolution = {
+            patches: [set({...textBlock, markDefs: EMPTY_MARKDEFS}, [{_key: textBlock._key}])],
+            description: `Block has invalid required property 'markDefs'.`,
+            action: 'Add empty markDefs array',
+            item: textBlock,
+
+            i18n: {
+              description:
+                'inputs.portable-text.invalid-value.missing-or-invalid-markdefs.description',
+              action: 'inputs.portable-text.invalid-value.missing-or-invalid-markdefs.action',
+              values: {key: textBlock._key},
+            },
+          }
+          return true
+        }
+        const allUsedMarks = uniq(
+          flatten(
+            textBlock.children
+              .filter((cld) => cld._type === types.span.name)
+              .map((cld) => cld.marks || []),
+          ) as string[],
+        )
+
+        // Test that all markDefs are in use (remove orphaned markDefs)
+        if (Array.isArray(blk.markDefs) && blk.markDefs.length > 0) {
+          const unusedMarkDefs: string[] = uniq(
+            blk.markDefs.map((def) => def._key).filter((key) => !allUsedMarks.includes(key)),
+          )
+          if (unusedMarkDefs.length > 0) {
+            resolution = {
+              autoResolve: true,
+              patches: unusedMarkDefs.map((markDefKey) =>
+                unset([{_key: blk._key}, 'markDefs', {_key: markDefKey}]),
+              ),
+              description: `Block contains orphaned data (unused mark definitions): ${unusedMarkDefs.join(
+                ', ',
+              )}.`,
+              action: 'Remove unused mark definition item',
+              item: blk,
+              i18n: {
+                description: 'inputs.portable-text.invalid-value.orphaned-mark-defs.description',
+                action: 'inputs.portable-text.invalid-value.orphaned-mark-defs.action',
+                values: {key: blk._key, unusedMarkDefs: unusedMarkDefs.map((m) => m.toString())},
+              },
+            }
+            return true
+          }
+        }
+
+        // Test that every annotation mark used has a definition
+        const annotationMarks = allUsedMarks.filter(
+          (mark) => !types.decorators.map((dec) => dec.value).includes(mark),
+        )
+        const orphanedMarks = annotationMarks.filter(
+          (mark) =>
+            textBlock.markDefs === undefined ||
+            !textBlock.markDefs.find((def) => def._key === mark),
+        )
+        if (orphanedMarks.length > 0) {
+          const spanChildren = textBlock.children.filter(
+            (cld) =>
+              cld._type === types.span.name &&
+              Array.isArray(cld.marks) &&
+              cld.marks.some((mark) => orphanedMarks.includes(mark)),
+          ) as PortableTextSpan[]
+          if (spanChildren) {
+            const orphaned = orphanedMarks.join(', ')
+            resolution = {
+              autoResolve: true,
+              patches: spanChildren.map((child) => {
+                return set(
+                  (child.marks || []).filter((cMrk) => !orphanedMarks.includes(cMrk)),
+                  [{_key: blk._key}, 'children', {_key: child._key}, 'marks'],
+                )
+              }),
+              description: `Block with _key '${blk._key}' contains marks (${orphaned}) not supported by the current content model.`,
+              action: 'Remove invalid marks',
+              item: blk,
+
+              i18n: {
+                description: 'inputs.portable-text.invalid-value.orphaned-marks.description',
+                action: 'inputs.portable-text.invalid-value.orphaned-marks.action',
+                values: {key: blk._key, orphanedMarks: orphanedMarks.map((m) => m.toString())},
+              },
+            }
+            return true
+          }
+        }
+
+        // Test every child
+        if (
+          textBlock.children.some((child, cIndex: number) => {
+            if (!isPlainObject(child)) {
+              resolution = {
+                patches: [unset([{_key: blk._key}, 'children', cIndex])],
+                description: `Child at index '${cIndex}' in block with key '${blk._key}' is not an object.`,
+                action: 'Remove the item',
+                item: blk,
+
+                i18n: {
+                  description: 'inputs.portable-text.invalid-value.non-object-child.description',
+                  action: 'inputs.portable-text.invalid-value.non-object-child.action',
+                  values: {key: blk._key, index: cIndex},
+                },
+              }
+              return true
+            }
+
+            if (!child._key || typeof child._key !== 'string') {
+              const newChild = {...child, _key: keyGenerator()}
+              resolution = {
+                autoResolve: true,
+                patches: [set(newChild, [{_key: blk._key}, 'children', cIndex])],
+                description: `Child at index ${cIndex} is missing required _key in block with _key ${blk._key}.`,
+                action: 'Set a new random _key on the object',
+                item: blk,
+
+                i18n: {
+                  description: 'inputs.portable-text.invalid-value.missing-child-key.description',
+                  action: 'inputs.portable-text.invalid-value.missing-child-key.action',
+                  values: {key: blk._key, index: cIndex},
+                },
+              }
+              return true
+            }
+
+            // Verify that children have valid types
+            if (!child._type) {
+              resolution = {
+                patches: [unset([{_key: blk._key}, 'children', {_key: child._key}])],
+                description: `Child with _key '${child._key}' in block with key '${blk._key}' is missing '_type' property.`,
+                action: 'Remove the object',
+                item: blk,
+
+                i18n: {
+                  description: 'inputs.portable-text.invalid-value.missing-child-type.description',
+                  action: 'inputs.portable-text.invalid-value.missing-child-type.action',
+                  values: {key: blk._key, childKey: child._key},
+                },
+              }
+              return true
+            }
+
+            if (!validChildTypes.includes(child._type)) {
+              resolution = {
+                patches: [unset([{_key: blk._key}, 'children', {_key: child._key}])],
+                description: `Child with _key '${child._key}' in block with key '${blk._key}' has invalid '_type' property (${child._type}).`,
+                action: 'Remove the object',
+                item: blk,
+
+                i18n: {
+                  description:
+                    'inputs.portable-text.invalid-value.disallowed-child-type.description',
+                  action: 'inputs.portable-text.invalid-value.disallowed-child-type.action',
+                  values: {key: blk._key, childKey: child._key, childType: child._type},
+                },
+              }
+              return true
+            }
+
+            // Verify that spans have .text property that is a string
+            if (child._type === types.span.name && typeof child.text !== 'string') {
+              resolution = {
+                patches: [
+                  set({...child, text: ''}, [{_key: blk._key}, 'children', {_key: child._key}]),
+                ],
+                description: `Child with _key '${child._key}' in block with key '${blk._key}' has missing or invalid text property!`,
+                action: `Write an empty text property to the object`,
+                item: blk,
+
+                i18n: {
+                  description: 'inputs.portable-text.invalid-value.invalid-span-text.description',
+                  action: 'inputs.portable-text.invalid-value.invalid-span-text.action',
+                  values: {key: blk._key, childKey: child._key},
+                },
+              }
+              return true
+            }
+            return false
+          })
+        ) {
+          valid = false
+        }
+      }
+      return false
+    })
+  ) {
+    valid = false
+  }
+  return {valid, resolution, value}
+}

package/src/utils/values.ts

@@ -0,0 +1,208 @@
+import {
+  type PathSegment,
+  type PortableTextBlock,
+  type PortableTextChild,
+  type PortableTextObject,
+  type PortableTextTextBlock,
+} from '@sanity/types'
+import {isEqual} from 'lodash'
+import {type Descendant, Element, type Node, Text} from 'slate'
+
+import {type PortableTextMemberSchemaTypes} from '../types/editor'
+
+export const EMPTY_MARKDEFS: PortableTextObject[] = []
+export const EMPTY_MARKS: string[] = []
+
+export const VOID_CHILD_KEY = 'void-child'
+
+type Partial<T> = {
+  [P in keyof T]?: T[P]
+}
+
+function keepObjectEquality(
+  object: PortableTextBlock | PortableTextChild,
+  keyMap: Record<string, PortableTextBlock | PortableTextChild>,
+) {
+  const value = keyMap[object._key]
+  if (value && isEqual(object, value)) {
+    return value
+  }
+  keyMap[object._key] = object
+  return object
+}
+
+export function toSlateValue(
+  value: PortableTextBlock[] | undefined,
+  {schemaTypes}: {schemaTypes: PortableTextMemberSchemaTypes},
+  keyMap: Record<string, any> = {},
+): Descendant[] {
+  if (value && Array.isArray(value)) {
+    return value.map((block) => {
+      const {_type, _key, ...rest} = block
+      const voidChildren = [{_key: VOID_CHILD_KEY, _type: 'span', text: '', marks: []}]
+      const isPortableText = block && block._type === schemaTypes.block.name
+      if (isPortableText) {
+        const textBlock = block as PortableTextTextBlock
+        let hasInlines = false
+        const hasMissingStyle = typeof textBlock.style === 'undefined'
+        const hasMissingMarkDefs = typeof textBlock.markDefs === 'undefined'
+        const hasMissingChildren = typeof textBlock.children === 'undefined'
+
+        const children = (textBlock.children || []).map((child) => {
+          const {_type: cType, _key: cKey, ...cRest} = child
+          // Return 'slate' version of inline object where the actual
+          // value is stored in the `value` property.
+          // In slate, inline objects are represented as regular
+          // children with actual text node in order to be able to
+          // be selected the same way as the rest of the (text) content.
+          if (cType !== 'span') {
+            hasInlines = true
+            return keepObjectEquality(
+              {
+                _type: cType,
+                _key: cKey,
+                children: voidChildren,
+                value: cRest,
+                __inline: true,
+              },
+              keyMap,
+            )
+          }
+          // Original child object (span)
+          return child
+        })
+        // Return original block
+        if (
+          !hasMissingStyle &&
+          !hasMissingMarkDefs &&
+          !hasMissingChildren &&
+          !hasInlines &&
+          Element.isElement(block)
+        ) {
+          // Original object
+          return block
+        }
+        // TODO: remove this when we have a better way to handle missing style
+        if (hasMissingStyle) {
+          rest.style = schemaTypes.styles[0].value
+        }
+        return keepObjectEquality({_type, _key, ...rest, children}, keyMap)
+      }
+      return keepObjectEquality(
+        {
+          _type,
+          _key,
+          children: voidChildren,
+          value: rest,
+        },
+        keyMap,
+      )
+    }) as Descendant[]
+  }
+  return []
+}
+
+export function fromSlateValue(
+  value: Descendant[],
+  textBlockType: string,
+  keyMap: Record<string, PortableTextBlock | PortableTextChild> = {},
+): PortableTextBlock[] {
+  return value.map((block) => {
+    const {_key, _type} = block
+    if (!_key || !_type) {
+      throw new Error('Not a valid block')
+    }
+    if (_type === textBlockType && 'children' in block && Array.isArray(block.children) && _key) {
+      let hasInlines = false
+      const children = block.children.map((child) => {
+        const {_type: _cType} = child
+        if ('value' in child && _cType !== 'span') {
+          hasInlines = true
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          const {value: v, _key: k, _type: t, __inline: _i, children: _c, ...rest} = child
+          return keepObjectEquality({...rest, ...v, _key: k as string, _type: t as string}, keyMap)
+        }
+        return child
+      })
+      if (!hasInlines) {
+        return block as PortableTextBlock // Original object
+      }
+      return keepObjectEquality({...block, children, _key, _type}, keyMap) as PortableTextBlock
+    }
+    const blockValue = 'value' in block && block.value
+    return keepObjectEquality(
+      {_key, _type, ...(typeof blockValue === 'object' ? blockValue : {})},
+      keyMap,
+    ) as PortableTextBlock
+  })
+}
+
+export function isEqualToEmptyEditor(
+  children: Descendant[] | PortableTextBlock[],
+  schemaTypes: PortableTextMemberSchemaTypes,
+): boolean {
+  return (
+    children === undefined ||
+    (children && Array.isArray(children) && children.length === 0) ||
+    (children &&
+      Array.isArray(children) &&
+      children.length === 1 &&
+      Element.isElement(children[0]) &&
+      children[0]._type === schemaTypes.block.name &&
+      'style' in children[0] &&
+      children[0].style === schemaTypes.styles[0].value &&
+      !('listItem' in children[0]) &&
+      Array.isArray(children[0].children) &&
+      children[0].children.length === 1 &&
+      Text.isText(children[0].children[0]) &&
+      children[0].children[0]._type === 'span' &&
+      !children[0].children[0].marks?.join('') &&
+      children[0].children[0].text === '')
+  )
+}
+
+export function findBlockAndIndexFromPath(
+  firstPathSegment: PathSegment,
+  children: (Node | Partial<Node>)[],
+): [Element | undefined, number | undefined] {
+  let blockIndex = -1
+  const isNumber = Number.isInteger(Number(firstPathSegment))
+  if (isNumber) {
+    blockIndex = Number(firstPathSegment)
+  } else if (children) {
+    blockIndex = children.findIndex(
+      (blk) => Element.isElement(blk) && isEqual({_key: blk._key}, firstPathSegment),
+    )
+  }
+  if (blockIndex > -1) {
+    return [children[blockIndex] as Element, blockIndex]
+  }
+  return [undefined, -1]
+}
+
+export function findChildAndIndexFromPath(
+  secondPathSegment: PathSegment,
+  block: Element,
+): [Element | Text | undefined, number] {
+  let childIndex = -1
+  const isNumber = Number.isInteger(Number(secondPathSegment))
+  if (isNumber) {
+    childIndex = Number(secondPathSegment)
+  } else {
+    childIndex = block.children.findIndex((child) => isEqual({_key: child._key}, secondPathSegment))
+  }
+  if (childIndex > -1) {
+    return [block.children[childIndex] as Element | Text, childIndex]
+  }
+  return [undefined, -1]
+}
+
+export function getValueOrInitialValue(
+  value: unknown,
+  initialValue: PortableTextBlock[],
+): PortableTextBlock[] | undefined {
+  if (value && Array.isArray(value) && value.length > 0) {
+    return value
+  }
+  return initialValue
+}

package/src/utils/weakMaps.ts

@@ -0,0 +1,24 @@
+import {type Editor, type Element, type Range} from 'slate'
+
+import {type EditorSelection} from '..'
+
+// Is the editor currently receiving remote changes that are being applied to the content?
+export const IS_PROCESSING_REMOTE_CHANGES: WeakMap<Editor, boolean> = new WeakMap()
+// Is the editor currently producing local changes that are not yet submitted?
+export const IS_PROCESSING_LOCAL_CHANGES: WeakMap<Editor, boolean> = new WeakMap()
+
+// Is the editor dragging something?
+export const IS_DRAGGING: WeakMap<Editor, boolean> = new WeakMap()
+// Is the editor dragging a element?
+export const IS_DRAGGING_BLOCK_ELEMENT: WeakMap<Editor, Element> = new WeakMap()
+
+// When dragging elements, this will be the target element
+export const IS_DRAGGING_ELEMENT_TARGET: WeakMap<Editor, Element> = new WeakMap()
+// Target position for dragging over a block
+export const IS_DRAGGING_BLOCK_TARGET_POSITION: WeakMap<Editor, 'top' | 'bottom'> = new WeakMap()
+
+export const KEY_TO_SLATE_ELEMENT: WeakMap<Editor, any | undefined> = new WeakMap()
+export const KEY_TO_VALUE_ELEMENT: WeakMap<Editor, any | undefined> = new WeakMap()
+
+// Keep object relation to slate range in the portable-text-range
+export const SLATE_TO_PORTABLE_TEXT_RANGE = new WeakMap<Range, EditorSelection>()

package/src/utils/withChanges.ts

@@ -0,0 +1,25 @@
+import {type Editor} from 'slate'
+
+import {IS_PROCESSING_LOCAL_CHANGES, IS_PROCESSING_REMOTE_CHANGES} from './weakMaps'
+
+export function withRemoteChanges(editor: Editor, fn: () => void): void {
+  const prev = isChangingRemotely(editor) || false
+  IS_PROCESSING_REMOTE_CHANGES.set(editor, true)
+  fn()
+  IS_PROCESSING_REMOTE_CHANGES.set(editor, prev)
+}
+
+export function isChangingRemotely(editor: Editor): boolean | undefined {
+  return IS_PROCESSING_REMOTE_CHANGES.get(editor)
+}
+
+export function withLocalChanges(editor: Editor, fn: () => void): void {
+  const prev = isChangingLocally(editor) || false
+  IS_PROCESSING_LOCAL_CHANGES.set(editor, true)
+  fn()
+  IS_PROCESSING_LOCAL_CHANGES.set(editor, prev)
+}
+
+export function isChangingLocally(editor: Editor): boolean | undefined {
+  return IS_PROCESSING_LOCAL_CHANGES.get(editor)
+}

package/src/utils/withPreserveKeys.ts

@@ -0,0 +1,14 @@
+import {type Editor} from 'slate'
+
+export const PRESERVE_KEYS: WeakMap<Editor, boolean | undefined> = new WeakMap()
+
+export function withPreserveKeys(editor: Editor, fn: () => void): void {
+  const prev = isPreservingKeys(editor)
+  PRESERVE_KEYS.set(editor, true)
+  fn()
+  PRESERVE_KEYS.set(editor, prev)
+}
+
+export function isPreservingKeys(editor: Editor): boolean | undefined {
+  return PRESERVE_KEYS.get(editor)
+}

package/src/utils/withoutPatching.ts

@@ -0,0 +1,14 @@
+import {type Editor} from 'slate'
+
+export const PATCHING: WeakMap<Editor, boolean | undefined> = new WeakMap()
+
+export function withoutPatching(editor: Editor, fn: () => void): void {
+  const prev = isPatching(editor)
+  PATCHING.set(editor, false)
+  fn()
+  PATCHING.set(editor, prev)
+}
+
+export function isPatching(editor: Editor): boolean | undefined {
+  return PATCHING.get(editor)
+}