@portabletext/editor 1.0.2 → 1.0.4

package/src/patch/array.ts

@@ -1,89 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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')
-}

package/src/types/patch.ts

@@ -1,65 +0,0 @@
-import {type Path} from '@sanity/types'
-
-export type JSONValue = number | string | boolean | {[key: string]: JSONValue} | JSONValue[]
-
-export type Origin = 'remote' | 'local' | 'internal'
-
-export type IncPatch = {
-  path: Path
-  origin?: Origin
-  type: 'inc'
-  value: JSONValue
-}
-
-export type DecPatch = {
-  path: Path
-  origin?: Origin
-  type: 'dec'
-  value: JSONValue
-}
-
-export type SetPatch = {
-  path: Path
-  type: 'set'
-  origin?: Origin
-  value: JSONValue
-}
-
-export type SetIfMissingPatch = {
-  path: Path
-  origin?: Origin
-  type: 'setIfMissing'
-  value: JSONValue
-}
-
-export type UnsetPatch = {
-  path: Path
-  origin?: Origin
-  type: 'unset'
-}
-
-export type InsertPosition = 'before' | 'after' | 'replace'
-
-export type InsertPatch = {
-  path: Path
-  origin?: Origin
-  type: 'insert'
-  position: InsertPosition
-  items: JSONValue[]
-}
-
-export type DiffMatchPatch = {
-  path: Path
-  type: 'diffMatchPatch'
-  origin?: Origin
-  value: string
-}
-
-export type Patch =
-  | SetPatch
-  | SetIfMissingPatch
-  | UnsetPatch
-  | InsertPatch
-  | DiffMatchPatch
-  | IncPatch
-  | DecPatch

package/src/utils/patches.ts

@@ -1,36 +0,0 @@
-import {isEqual} from 'lodash'
-
-import {type Patch} from '../types/patch'
-
-/**
- * Try to compact a set of patches
- *
- */
-export function compactPatches(patches: Patch[]) {
-  // If the last patch is unsetting everything, just do that
-  const lastPatch = patches.slice(-1)[0]
-  if (lastPatch && lastPatch.type === 'unset' && lastPatch.path.length === 0) {
-    return [lastPatch]
-  }
-  let finalPatches = patches
-  // Run through the patches and remove any redundant ones.
-  finalPatches = finalPatches.filter((patch, index) => {
-    if (!patch) {
-      return false
-    }
-    const nextPatch = finalPatches[index + 1]
-    if (
-      nextPatch &&
-      nextPatch.type === 'set' &&
-      patch.type === 'set' &&
-      isEqual(patch.path, nextPatch.path)
-    ) {
-      return false
-    }
-    return true
-  })
-  if (finalPatches.length !== patches.length) {
-    return finalPatches
-  }
-  return patches
-}