@portabletext/editor 0.0.0

package/src/editor/plugins/index.ts

@@ -0,0 +1,155 @@
+import {noop} from 'lodash'
+import {type BaseOperation, type Editor, type Node, type NodeEntry} from 'slate'
+
+import {type PortableTextSlateEditor} from '../../types/editor'
+import {type createEditorOptions} from '../../types/options'
+import {createOperationToPatches} from '../../utils/operationToPatches'
+import {createWithEditableAPI} from './createWithEditableAPI'
+import {createWithInsertBreak} from './createWithInsertBreak'
+import {createWithMaxBlocks} from './createWithMaxBlocks'
+import {createWithObjectKeys} from './createWithObjectKeys'
+import {createWithPatches} from './createWithPatches'
+import {createWithPlaceholderBlock} from './createWithPlaceholderBlock'
+import {createWithPortableTextBlockStyle} from './createWithPortableTextBlockStyle'
+import {createWithPortableTextLists} from './createWithPortableTextLists'
+import {createWithPortableTextMarkModel} from './createWithPortableTextMarkModel'
+import {createWithPortableTextSelections} from './createWithPortableTextSelections'
+import {createWithSchemaTypes} from './createWithSchemaTypes'
+import {createWithUndoRedo} from './createWithUndoRedo'
+import {createWithUtils} from './createWithUtils'
+
+export {createWithEditableAPI} from './createWithEditableAPI'
+export {createWithHotkeys} from './createWithHotKeys'
+export {createWithInsertData} from './createWithInsertData'
+export {createWithMaxBlocks} from './createWithMaxBlocks'
+export {createWithObjectKeys} from './createWithObjectKeys'
+export {createWithPatches} from './createWithPatches'
+export {createWithPortableTextBlockStyle} from './createWithPortableTextBlockStyle'
+export {createWithPortableTextLists} from './createWithPortableTextLists'
+export {createWithPortableTextMarkModel} from './createWithPortableTextMarkModel'
+export {createWithPortableTextSelections} from './createWithPortableTextSelections'
+export {createWithSchemaTypes} from './createWithSchemaTypes'
+export {createWithUndoRedo} from './createWithUndoRedo'
+export {createWithUtils} from './createWithUtils'
+
+export interface OriginalEditorFunctions {
+  apply: (operation: BaseOperation) => void
+  onChange: () => void
+  normalizeNode: (entry: NodeEntry<Node>) => void
+}
+
+const originalFnMap = new WeakMap<PortableTextSlateEditor, OriginalEditorFunctions>()
+
+export const withPlugins = <T extends Editor>(
+  editor: T,
+  options: createEditorOptions,
+): {editor: PortableTextSlateEditor; subscribe: () => () => void} => {
+  const e = editor as T & PortableTextSlateEditor
+  const {keyGenerator, portableTextEditor, patches$, readOnly, maxBlocks} = options
+  const {schemaTypes, change$} = portableTextEditor
+  e.subscriptions = []
+  if (e.destroy) {
+    e.destroy()
+  } else {
+    // Save a copy of the original editor functions here before they were changed by plugins.
+    // We will put them back when .destroy is called (see below).
+    originalFnMap.set(e, {
+      apply: e.apply,
+      onChange: e.onChange,
+      normalizeNode: e.normalizeNode,
+    })
+  }
+  const operationToPatches = createOperationToPatches(schemaTypes)
+  const withObjectKeys = createWithObjectKeys(schemaTypes, keyGenerator)
+  const withSchemaTypes = createWithSchemaTypes({schemaTypes, keyGenerator})
+  const withEditableAPI = createWithEditableAPI(portableTextEditor, schemaTypes, keyGenerator)
+  const withPatches = createWithPatches({
+    change$,
+    keyGenerator,
+    patches$,
+    patchFunctions: operationToPatches,
+    readOnly,
+    schemaTypes,
+  })
+  const withMaxBlocks = createWithMaxBlocks(maxBlocks || -1)
+  const withPortableTextLists = createWithPortableTextLists(schemaTypes)
+  const withUndoRedo = createWithUndoRedo({
+    readOnly,
+    patches$,
+    blockSchemaType: schemaTypes.block,
+  })
+  const withPortableTextMarkModel = createWithPortableTextMarkModel(schemaTypes, change$)
+  const withPortableTextBlockStyle = createWithPortableTextBlockStyle(schemaTypes)
+
+  const withPlaceholderBlock = createWithPlaceholderBlock()
+
+  const withInsertBreak = createWithInsertBreak(schemaTypes)
+
+  const withUtils = createWithUtils({keyGenerator, schemaTypes, portableTextEditor})
+  const withPortableTextSelections = createWithPortableTextSelections(change$, schemaTypes)
+
+  e.destroy = () => {
+    const originalFunctions = originalFnMap.get(e)
+    if (!originalFunctions) {
+      throw new Error('Could not find pristine versions of editor functions')
+    }
+    e.apply = originalFunctions.apply
+    e.history = {undos: [], redos: []}
+    e.normalizeNode = originalFunctions.normalizeNode
+    e.onChange = originalFunctions.onChange
+  }
+  if (readOnly) {
+    return {
+      editor: withSchemaTypes(
+        withObjectKeys(
+          withPortableTextMarkModel(
+            withPortableTextBlockStyle(
+              withUtils(
+                withPlaceholderBlock(
+                  withPortableTextLists(
+                    withPortableTextSelections(withEditableAPI(withInsertBreak(e))),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      ),
+      subscribe: () => noop,
+    }
+  }
+
+  // Ordering is important here, selection dealing last, data manipulation in the middle and core model stuff first.
+  return {
+    editor: withSchemaTypes(
+      withObjectKeys(
+        withPortableTextMarkModel(
+          withPortableTextBlockStyle(
+            withPortableTextLists(
+              withPlaceholderBlock(
+                withUtils(
+                  withMaxBlocks(
+                    withUndoRedo(
+                      withPatches(withPortableTextSelections(withEditableAPI(withInsertBreak(e)))),
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      ),
+    ),
+    subscribe: () => {
+      const unsubscribes: (() => void)[] = []
+      editor.subscriptions.forEach((subscribeFn) => {
+        unsubscribes.push(subscribeFn())
+      })
+      return () => {
+        unsubscribes.forEach((unsubscribeFn) => {
+          unsubscribeFn()
+        })
+      }
+    },
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export type {PortableTextEditableProps} from './editor/Editable'
+export {PortableTextEditable} from './editor/Editable'
+export {usePortableTextEditor} from './editor/hooks/usePortableTextEditor'
+export {defaultKeyGenerator as keyGenerator} from './editor/hooks/usePortableTextEditorKeyGenerator'
+export {usePortableTextEditorSelection} from './editor/hooks/usePortableTextEditorSelection'
+export type {PortableTextEditorProps} from './editor/PortableTextEditor'
+export {PortableTextEditor} from './editor/PortableTextEditor'
+export * from './types/editor'
+export * from './types/options'
+export * from './types/patch'
+export {compactPatches} from './utils/patches'

package/src/patch/PatchEvent.ts

@@ -0,0 +1,33 @@
+import {type PathSegment} from '@sanity/types'
+import {flatten} from 'lodash'
+
+import {type Patch} from '../types/patch'
+import {diffMatchPatch, insert, prefixPath, set, setIfMissing, unset} from './patches'
+
+type PatchArg = Patch | Array<Patch>
+
+export default class PatchEvent {
+  static from(...patches: Array<PatchArg>) {
+    return new PatchEvent(flatten(patches))
+  }
+
+  patches: Array<Patch>
+
+  constructor(patches: Array<Patch>) {
+    this.patches = patches
+  }
+
+  prepend(...patches: Array<PatchArg>): PatchEvent {
+    return PatchEvent.from([...flatten(patches), ...this.patches])
+  }
+
+  append(...patches: Array<PatchArg>): PatchEvent {
+    return PatchEvent.from([...this.patches, ...flatten(patches)])
+  }
+
+  prefixAll(segment: PathSegment): PatchEvent {
+    return PatchEvent.from(this.patches.map((patch) => prefixPath(patch, segment)))
+  }
+}
+
+export {diffMatchPatch, insert, PatchEvent, set, setIfMissing, unset}

package/src/patch/applyPatch.ts

@@ -0,0 +1,29 @@
+import {isObject, isString} from 'lodash'
+
+import applyArrayPatch from './array'
+import applyObjectPatch from './object'
+import applyPrimitivePatch from './primitive'
+import applyStringPatch from './string'
+
+export function applyAll(value: any, patches: any[]) {
+  return patches.reduce(_apply, value)
+}
+
+function applyPatch(value: string, patch: {type: string; path: any[]; value: any}) {
+  if (Array.isArray(value)) {
+    return applyArrayPatch(value, patch as any)
+  }
+  if (isString(value)) {
+    return applyStringPatch(value, patch)
+  }
+  if (isObject(value)) {
+    return applyObjectPatch(value, patch)
+  }
+  return applyPrimitivePatch(value, patch)
+}
+
+export default function _apply(value: string, patch: {type: string; path: any[]; value: any}) {
+  const res = applyPatch(value, patch)
+  // console.log('applyPatch(%o, %o) : %o (noop? %o)', value, patch, res, value === res)
+  return res
+}

package/src/patch/array.ts

@@ -0,0 +1,89 @@
+import {type PathSegment} from '@sanity/types'
+import {findIndex} from 'lodash'
+
+import applyPatch from './applyPatch'
+import insert from './arrayInsert'
+
+const hasOwn = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty)
+
+function move(arr: any[], from: number, to: any) {
+  const nextValue = arr.slice()
+  const val = nextValue[from]
+  nextValue.splice(from, 1)
+  nextValue.splice(to, 0, val)
+  return nextValue
+}
+
+function findTargetIndex(array: any[], pathSegment: PathSegment) {
+  if (typeof pathSegment === 'number') {
+    return pathSegment
+  }
+  const index = findIndex(array, pathSegment)
+  return index === -1 ? false : index
+}
+
+export default function apply(
+  value: any,
+  patch: {type: any; path: any; value: any; position: any; items: any},
+) {
+  const nextValue = value.slice() // make a copy for internal mutation
+
+  if (patch.path.length === 0) {
+    // its directed to me
+    if (patch.type === 'setIfMissing') {
+      if (!Array.isArray(patch.value)) {
+        // eslint-disable-line max-depth
+        throw new Error('Cannot set value of an array to a non-array')
+      }
+      return value === undefined ? patch.value : value
+    } else if (patch.type === 'set') {
+      if (!Array.isArray(patch.value)) {
+        // eslint-disable-line max-depth
+        throw new Error('Cannot set value of an array to a non-array')
+      }
+      return patch.value
+    } else if (patch.type === 'unset') {
+      return undefined
+    } else if (patch.type === 'move') {
+      if (!patch.value || !hasOwn(patch.value, 'from') || !hasOwn(patch.value, 'to')) {
+        // eslint-disable-line max-depth
+        throw new Error(
+          `Invalid value of 'move' patch. Expected a value with "from" and "to" indexes, instead got: ${JSON.stringify(
+            patch.value,
+          )}`,
+        )
+      }
+      return move(nextValue, patch.value.from, patch.value.to)
+    }
+    throw new Error(`Invalid array operation: ${patch.type}`)
+  }
+
+  const [head, ...tail] = patch.path
+
+  const index = findTargetIndex(value, head)
+
+  // If the given selector could not be found, return as-is
+  if (index === false) {
+    return nextValue
+  }
+
+  if (tail.length === 0) {
+    if (patch.type === 'insert') {
+      const {position, items} = patch
+      return insert(value, position, index, items)
+    } else if (patch.type === 'unset') {
+      if (typeof index !== 'number') {
+        throw new Error(`Expected array index to be a number, instead got "${index}"`)
+      }
+      nextValue.splice(index, 1)
+      return nextValue
+    }
+  }
+
+  // The patch is not directed to me
+  nextValue[index] = applyPatch(nextValue[index], {
+    ...patch,
+    path: tail,
+  })
+  return nextValue
+}

package/src/patch/arrayInsert.ts

@@ -0,0 +1,27 @@
+export const BEFORE = 'before'
+export const AFTER = 'after'
+
+export default function insert(array: any[], position: string, index: number, ...args: any[]) {
+  if (position !== BEFORE && position !== AFTER) {
+    throw new Error(`Invalid position "${position}", must be either ${BEFORE} or ${AFTER}`)
+  }
+
+  const items = flatten(...args)
+
+  if (array.length === 0) {
+    return items
+  }
+
+  const len = array.length
+  const idx = Math.abs((len + index) % len) % len
+
+  const normalizedIdx = position === 'after' ? idx + 1 : idx
+
+  const copy = array.slice()
+  copy.splice(normalizedIdx, 0, ...flatten(items))
+  return copy
+}
+
+function flatten(...values: any[]) {
+  return values.reduce((prev, item) => prev.concat(item), [])
+}

package/src/patch/object.ts

@@ -0,0 +1,39 @@
+import {clone, isObject, omit} from 'lodash'
+
+import applyPatch from './applyPatch'
+
+export default function apply(value: any, patch: {type: any; path: any; value: any}) {
+  const nextValue = clone(value)
+  if (patch.path.length === 0) {
+    // its directed to me
+    if (patch.type === 'set') {
+      if (!isObject(patch.value)) {
+        // eslint-disable-line max-depth
+        throw new Error('Cannot set value of an object to a non-object')
+      }
+      return patch.value
+    } else if (patch.type === 'unset') {
+      return undefined
+    } else if (patch.type === 'setIfMissing') {
+      // console.log('IS IT missing?', value)
+      return value === undefined ? patch.value : value
+    }
+    throw new Error(`Invalid object operation: ${patch.type}`)
+  }
+
+  // The patch is not directed to me
+  const [head, ...tail] = patch.path
+  if (typeof head !== 'string') {
+    throw new Error(`Expected field name to be a string, instad got: ${head}`)
+  }
+
+  if (tail.length === 0 && patch.type === 'unset') {
+    return omit(nextValue, head)
+  }
+
+  nextValue[head] = applyPatch(nextValue[head], {
+    ...patch,
+    path: tail,
+  })
+  return nextValue
+}

package/src/patch/patches.ts

@@ -0,0 +1,53 @@
+import {makePatches, stringifyPatches} from '@sanity/diff-match-patch'
+import {type Path, type PathSegment} from '@sanity/types'
+
+import {
+  type DiffMatchPatch,
+  type InsertPatch,
+  type InsertPosition,
+  type SetIfMissingPatch,
+  type SetPatch,
+  type UnsetPatch,
+} from '../types/patch'
+
+export function setIfMissing(value: any, path: Path = []): SetIfMissingPatch {
+  return {
+    type: 'setIfMissing',
+    path,
+    value,
+  }
+}
+
+export function diffMatchPatch(
+  currentValue: string,
+  nextValue: string,
+  path: Path = [],
+): DiffMatchPatch {
+  const patches = makePatches(currentValue, nextValue)
+  const patch = stringifyPatches(patches)
+  return {type: 'diffMatchPatch', path, value: patch}
+}
+
+export function insert(items: any[], position: InsertPosition, path: Path = []): InsertPatch {
+  return {
+    type: 'insert',
+    path,
+    position,
+    items,
+  }
+}
+
+export function set(value: any, path: Path = []): SetPatch {
+  return {type: 'set', path, value}
+}
+
+export function unset(path: Path = []): UnsetPatch {
+  return {type: 'unset', path}
+}
+
+export function prefixPath<T extends {path: Path}>(patch: T, segment: PathSegment): T {
+  return {
+    ...patch,
+    path: [segment, ...patch.path],
+  }
+}

package/src/patch/primitive.ts

@@ -0,0 +1,43 @@
+const OPERATIONS: Record<string, any> = {
+  replace(_currentValue: any, nextValue: any) {
+    return nextValue
+  },
+  set(_currentValue: any, nextValue: any) {
+    return nextValue
+  },
+  setIfMissing(currentValue: any, nextValue: any) {
+    return currentValue === undefined ? nextValue : currentValue
+  },
+  unset(_currentValue: any, _nextValue: any) {
+    return undefined
+  },
+  inc(currentValue: any, nextValue: any) {
+    return currentValue + nextValue
+  },
+  dec(currentValue: any, nextValue: any) {
+    return currentValue - nextValue
+  },
+}
+
+const SUPPORTED_PATCH_TYPES = Object.keys(OPERATIONS)
+
+export default function apply(value: any, patch: any) {
+  if (!SUPPORTED_PATCH_TYPES.includes(patch.type)) {
+    throw new Error(
+      `Received patch of unsupported type: "${JSON.stringify(
+        patch.type,
+      )}" for primitives. This is most likely a bug.`,
+    )
+  }
+
+  if (patch.path.length > 0) {
+    throw new Error(
+      `Cannot apply deep operations on primitive values. Received patch with type "${
+        patch.type
+      }" and path "${patch.path
+        .map((path: any) => JSON.stringify(path))
+        .join('.')} that targeted the value "${JSON.stringify(value)}"`,
+    )
+  }
+  return OPERATIONS[patch.type](value, patch.value)
+}

package/src/patch/string.ts

@@ -0,0 +1,51 @@
+import {applyPatches, parsePatch} from '@sanity/diff-match-patch'
+
+type fn = (oldVal: any, newVal: any) => any
+const OPERATIONS: Record<string, fn> = {
+  replace(currentValue: any, nextValue: any) {
+    return nextValue
+  },
+  set(currentValue: any, nextValue: any) {
+    return nextValue
+  },
+  setIfMissing(currentValue: undefined, nextValue: any) {
+    return currentValue === undefined ? nextValue : currentValue
+  },
+  unset(currentValue: any, nextValue: any) {
+    return undefined
+  },
+  diffMatchPatch(currentValue: string, nextValue: string): string {
+    const [result] = applyPatches(parsePatch(nextValue), currentValue, {
+      allowExceedingIndices: true,
+    })
+    return result
+  },
+}
+
+const SUPPORTED_PATCH_TYPES = Object.keys(OPERATIONS)
+
+export default function apply(
+  value: string,
+  patch: {type: string; path: any[]; value: any},
+): string {
+  if (!SUPPORTED_PATCH_TYPES.includes(patch.type)) {
+    throw new Error(
+      `Received patch of unsupported type: "${JSON.stringify(
+        patch.type,
+      )}" for string. This is most likely a bug.`,
+    )
+  }
+
+  if (patch.path.length > 0) {
+    throw new Error(
+      `Cannot apply deep operations on string values. Received patch with type "${
+        patch.type
+      }" and path "${patch.path.join('.')} that targeted the value "${JSON.stringify(value)}"`,
+    )
+  }
+  const func = OPERATIONS[patch.type]
+  if (func) {
+    return func(value, patch.value)
+  }
+  throw new Error('Unknown patch type')
+}