@sanity/sdk 2.0.2 → 2.1.0

package/src/document/patchOperations.ts

@@ -1,11 +1,10 @@
 import {applyPatches, parsePatch} from '@sanity/diff-match-patch'
+import {getIndexForKey, jsonMatch, slicePath, stringifyPath} from '@sanity/json-match'
 import {
   type IndexTuple,
   type InsertPatch,
   isKeyedObject,
   isKeySegment,
-  type KeyedSegment,
-  type Path,
   type PathSegment,
 } from '@sanity/types'
 
@@ -113,235 +112,6 @@ type DeepGet<TValue, TPath extends readonly (string | number)[]> = TPath extends
  */
 export type JsonMatch<TDocument, TPath extends string> = DeepGet<TDocument, PathParts<TPath>>
 
-function parseBracketContent(content: string): PathSegment {
-  // 1) Range match:  ^(\d*):(\d*)$
-  //    - start or end can be empty (meaning "start" or "end" of array)
-  const rangeMatch = content.match(/^(\d*):(\d*)$/)
-  if (rangeMatch) {
-    const startStr = rangeMatch[1]
-    const endStr = rangeMatch[2]
-    const start: number | '' = startStr === '' ? '' : parseInt(startStr, 10)
-    const end: number | '' = endStr === '' ? '' : parseInt(endStr, 10)
-    return [start, end]
-  }
-
-  // 2) Keyed segment match:  ^_key==["'](.*)["']$
-  //    (We allow either double or single quotes for the value)
-  const keyedMatch = content.match(/^_key==["'](.+)["']$/)
-  if (keyedMatch) {
-    return {_key: keyedMatch[1]}
-  }
-
-  // 3) Single index (positive or negative)
-  const index = parseInt(content, 10)
-  if (!isNaN(index)) {
-    return index
-  }
-
-  throw new Error(`Invalid bracket content: "[${content}]"`)
-}
-
-function parseSegment(segment: string): PathSegment[] {
-  // Each "segment" can contain:
-  // - A leading property name (optional).
-  // - Followed by zero or more bracket expressions, e.g. foo[1][_key=="bar"][2:9].
-  //
-  // We'll collect these into an array of path segments.
-
-  const segments: PathSegment[] = []
-  let idx = 0
-
-  // Helper to push a string if it's not empty
-  function pushIfNotEmpty(text: string) {
-    if (text) {
-      segments.push(text)
-    }
-  }
-
-  while (idx < segment.length) {
-    // Look for the next '['
-    const openIndex = segment.indexOf('[', idx)
-    if (openIndex === -1) {
-      // No more brackets – whatever remains is a plain string key
-      const remaining = segment.slice(idx)
-      pushIfNotEmpty(remaining)
-      break
-    }
-
-    // Push text before this bracket (as a string key) if not empty
-    const before = segment.slice(idx, openIndex)
-    pushIfNotEmpty(before)
-
-    // Find the closing bracket
-    const closeIndex = segment.indexOf(']', openIndex)
-    if (closeIndex === -1) {
-      throw new Error(`Unmatched "[" in segment: "${segment}"`)
-    }
-
-    // Extract the bracket content
-    const bracketContent = segment.slice(openIndex + 1, closeIndex)
-    segments.push(parseBracketContent(bracketContent))
-
-    // Move past the bracket
-    idx = closeIndex + 1
-  }
-
-  return segments
-}
-
-export function parsePath(path: string): Path {
-  // We want to split on '.' outside of brackets. A simple approach is
-  // to track "are we in bracket or not?" while scanning.
-  const result: Path = []
-  let buffer = ''
-  let bracketDepth = 0
-
-  for (let i = 0; i < path.length; i++) {
-    const ch = path[i]
-    if (ch === '[') {
-      bracketDepth++
-      buffer += ch
-    } else if (ch === ']') {
-      bracketDepth--
-      buffer += ch
-    } else if (ch === '.' && bracketDepth === 0) {
-      // We hit a dot at the top level → this ends one segment
-      if (buffer) {
-        result.push(...parseSegment(buffer))
-        buffer = ''
-      }
-    } else {
-      buffer += ch
-    }
-  }
-
-  // If there's anything left in the buffer, parse it
-  if (buffer) {
-    result.push(...parseSegment(buffer))
-  }
-
-  return result
-}
-
-export function stringifyPath(path: Path): string {
-  let result = ''
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i]
-
-    if (typeof segment === 'string') {
-      // If not the first segment and the previous segment was
-      // not a bracket form, we add a dot
-      if (result) {
-        result += '.'
-      }
-      result += segment
-    } else if (typeof segment === 'number') {
-      // Single index
-      result += `[${segment}]`
-    } else if (Array.isArray(segment)) {
-      // Index tuple
-      const [start, end] = segment
-      const startStr = start === '' ? '' : String(start)
-      const endStr = end === '' ? '' : String(end)
-      result += `[${startStr}:${endStr}]`
-    } else {
-      // Keyed segment
-      // e.g. {_key: "someValue"} => [_key=="someValue"]
-      result += `[_key=="${segment._key}"]`
-    }
-  }
-  return result
-}
-
-type MatchEntry<T = unknown> = {
-  value: T
-  path: SingleValuePath
-}
-
-/**
- * A very simplified implementation of [JSONMatch][0] that only supports:
- * - descent e.g. `friend.name`
- * - array index e.g. `items[-1]`
- * - array matching with `_key` e.g. `items[_key=="dd9efe09"]`
- * - array matching with a range e.g. `items[4:]`
- *
- * E.g. `friends[_key=="dd9efe09"].address.zip`
- *
- * [0]: https://www.sanity.io/docs/json-match
- *
- * @beta
- */
-export function jsonMatch<TDocument, TPath extends string>(
-  input: TDocument,
-  path: TPath,
-): MatchEntry<JsonMatch<TDocument, TPath>>[]
-/** @beta */
-export function jsonMatch<TValue>(input: unknown, path: string): MatchEntry<TValue>[]
-/** @beta */
-export function jsonMatch(input: unknown, pathExpression: string): MatchEntry[] {
-  return matchRecursive(input, parsePath(pathExpression), [])
-}
-
-function matchRecursive(value: unknown, path: Path, currentPath: SingleValuePath): MatchEntry[] {
-  // If we've consumed the entire path, return the final match
-  if (path.length === 0) {
-    return [{value, path: currentPath}]
-  }
-
-  const [head, ...rest] = path
-
-  // 1) String segment => object property
-  if (typeof head === 'string') {
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-      const obj = value as Record<string, unknown>
-      const nextValue = obj[head]
-      return matchRecursive(nextValue, rest, [...currentPath, head])
-    }
-    // If not an object with that property, no match
-    return []
-  }
-
-  // 2) Numeric segment => array index
-  if (typeof head === 'number') {
-    if (Array.isArray(value)) {
-      const nextValue = value.at(head)
-      return matchRecursive(nextValue, rest, [...currentPath, head])
-    }
-    // If not an array, no match
-    return []
-  }
-
-  // 3) Index tuple => multiple indices
-  if (Array.isArray(head)) {
-    // This is a range: [start, end]
-    if (!Array.isArray(value)) {
-      // If not an array, no match
-      return []
-    }
-
-    const [start, end] = head
-    // Convert empty strings '' to the start/end of the array
-    const startIndex = start === '' ? 0 : start
-    const endIndex = end === '' ? value.length : end
-
-    // We'll accumulate all matches from each index in the range
-    return value
-      .slice(startIndex, endIndex)
-      .flatMap((item, i) => matchRecursive(item, rest, [...currentPath, i + startIndex]))
-  }
-
-  // 4) Keyed segment => find index in array
-  //    e.g. {_key: 'foo'}
-  const keyed = head as KeyedSegment
-  const arrIndex = getIndexForKey(value, keyed._key)
-  if (arrIndex === undefined || !Array.isArray(value)) {
-    return []
-  }
-
-  const nextVal = value[arrIndex]
-  return matchRecursive(nextVal, rest, [...currentPath, {_key: keyed._key}])
-}
-
 // this is a similar array key to the studio:
 // https://github.com/sanity-io/sanity/blob/v3.74.1/packages/sanity/src/core/form/inputs/arrays/ArrayOfObjectsInput/createProtoArrayValue.ts
 function generateArrayKey(length: number = 12): string {
@@ -423,7 +193,7 @@ export function set<R>(input: unknown, pathExpressionValues: Record<string, unkn
 export function set(input: unknown, pathExpressionValues: Record<string, unknown>): unknown {
   const result = Object.entries(pathExpressionValues)
     .flatMap(([pathExpression, replacementValue]) =>
-      jsonMatch(input, pathExpression).map((matchEntry) => ({
+      Array.from(jsonMatch(input, pathExpression)).map((matchEntry) => ({
         ...matchEntry,
         replacementValue,
       })),
@@ -455,7 +225,7 @@ export function setIfMissing(
 ): unknown {
   const result = Object.entries(pathExpressionValues)
     .flatMap(([pathExpression, replacementValue]) => {
-      return jsonMatch(input, pathExpression).map((matchEntry) => ({
+      return Array.from(jsonMatch(input, pathExpression)).map((matchEntry) => ({
         ...matchEntry,
         replacementValue,
       }))
@@ -483,7 +253,7 @@ export function setIfMissing(
 export function unset<R>(input: unknown, pathExpressions: string[]): R
 export function unset(input: unknown, pathExpressions: string[]): unknown {
   const result = pathExpressions
-    .flatMap((pathExpression) => jsonMatch(input, pathExpression))
+    .flatMap((pathExpression) => Array.from(jsonMatch(input, pathExpression)))
     // ensure that we remove in the reverse order the paths were found in
     // this is necessary for array unsets so the indexes don't change as we unset
     .reverse()
@@ -595,18 +365,15 @@ export function insert(input: unknown, {items, ...insertPatch}: InsertPatch): un
   if (!operation) return input
   if (typeof pathExpression !== 'string') return input
 
-  const parsedPath = parsePath(pathExpression)
   // in order to do an insert patch, you need to provide at least one path segment
-  if (!parsedPath.length) return input
+  if (!pathExpression.length) return input
 
-  const arrayPath = stringifyPath(parsedPath.slice(0, -1))
-  const positionPath = stringifyPath(parsedPath.slice(-1))
-
-  const arrayMatches = jsonMatch<unknown[]>(input, arrayPath)
+  const arrayPath = slicePath(pathExpression, 0, -1)
+  const positionPath = slicePath(pathExpression, -1)
 
   let result = input
 
-  for (const {path, value} of arrayMatches) {
+  for (const {path, value} of jsonMatch(input, arrayPath)) {
     if (!Array.isArray(value)) continue
     let arr = value
 
@@ -725,7 +492,7 @@ export function inc<R>(input: unknown, pathExpressionValues: Record<string, numb
 export function inc(input: unknown, pathExpressionValues: Record<string, number>): unknown {
   const result = Object.entries(pathExpressionValues)
     .flatMap(([pathExpression, valueToAdd]) =>
-      jsonMatch(input, pathExpression).map((matchEntry) => ({
+      Array.from(jsonMatch(input, pathExpression)).map((matchEntry) => ({
         ...matchEntry,
         valueToAdd,
       })),
@@ -789,7 +556,9 @@ export function diffMatchPatch(
   pathExpressionValues: Record<string, string>,
 ): unknown {
   const result = Object.entries(pathExpressionValues)
-    .flatMap(([pathExpression, dmp]) => jsonMatch(input, pathExpression).map((m) => ({...m, dmp})))
+    .flatMap(([pathExpression, dmp]) =>
+      Array.from(jsonMatch(input, pathExpression)).map((m) => ({...m, dmp})),
+    )
     .filter((i) => i.value !== undefined)
     .map(({path, value, dmp}) => {
       if (typeof value !== 'string') {
@@ -832,21 +601,6 @@ export function ifRevisionID(input: unknown, revisionId: string): unknown {
   return input
 }
 
-const indexCache = new WeakMap<KeyedSegment[], Record<string, number | undefined>>()
-export function getIndexForKey(input: unknown, key: string): number | undefined {
-  if (!Array.isArray(input)) return undefined
-  const cached = indexCache.get(input)
-  if (cached) return cached[key]
-
-  const lookup = input.reduce<Record<string, number | undefined>>((acc, next, index) => {
-    if (typeof next?._key === 'string') acc[next._key] = index
-    return acc
-  }, {})
-
-  indexCache.set(input, lookup)
-  return lookup[key]
-}
-
 /**
  * Gets a value deep inside of an object given a path. If the path does not
  * exist in the object, `undefined` will be returned.
@@ -915,7 +669,7 @@ export function setDeep(input: unknown, path: SingleValuePath, value: unknown):
   if (Array.isArray(input)) {
     let index: number | undefined
     if (isKeySegment(currentSegment)) {
-      index = getIndexForKey(input, currentSegment._key)
+      index = getIndexForKey(input, currentSegment._key) ?? input.length
     } else if (typeof currentSegment === 'number') {
       // Support negative indexes by computing the proper positive index.
       index = currentSegment < 0 ? input.length + currentSegment : currentSegment