@sanity/diff-patch 5.0.0 → 7.0.0

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/paths.ts","../src/diffError.ts","../src/validate.ts","../src/diffPatch.ts"],"sourcesContent":["import type {KeyedSanityObject} from './diffPatch.js'\n\nconst IS_DOTTABLE_RE = /^[A-Za-z_][A-Za-z0-9_]*$/\n\n/**\n * A segment of a path\n *\n * @public\n */\nexport type PathSegment =\n  | string // Property\n  | number // Array index\n  | {_key: string} // Array `_key` lookup\n  | [number | '', number | ''] // From/to array index\n\n/**\n * An array of path segments representing a path in a document\n *\n * @public\n */\nexport type Path = PathSegment[]\n\n/**\n * Converts an array path to a string path\n *\n * @param path - The array path to convert\n * @returns A stringified path\n * @internal\n */\nexport function pathToString(path: Path): string {\n  return path.reduce((target: string, segment: PathSegment, i: number) => {\n    if (Array.isArray(segment)) {\n      return `${target}[${segment.join(':')}]`\n    }\n\n    if (isKeyedObject(segment)) {\n      return `${target}[_key==\"${segment._key}\"]`\n    }\n\n    if (typeof segment === 'number') {\n      return `${target}[${segment}]`\n    }\n\n    if (typeof segment === 'string' && !IS_DOTTABLE_RE.test(segment)) {\n      return `${target}['${segment}']`\n    }\n\n    if (typeof segment === 'string') {\n      const separator = i === 0 ? '' : '.'\n      return `${target}${separator}${segment}`\n    }\n\n    throw new Error(`Unsupported path segment \"${segment}\"`)\n  }, '')\n}\n\nfunction isKeyedObject(obj: any): obj is KeyedSanityObject {\n  return typeof obj === 'object' && typeof obj._key === 'string'\n}\n","import {type Path, pathToString} from './paths.js'\n\n/**\n * Represents an error that occurred during a diff process.\n * Contains `path`, `value` and `serializedPath` properties,\n * which is helpful for debugging and showing friendly messages.\n *\n * @public\n */\nexport class DiffError extends Error {\n  public path: Path\n  public value: unknown\n  public serializedPath: string\n\n  constructor(message: string, path: Path, value?: unknown) {\n    const serializedPath = pathToString(path)\n    super(`${message} (at '${serializedPath}')`)\n\n    this.path = path\n    this.serializedPath = serializedPath\n    this.value = value\n  }\n}\n","import {DiffError} from './diffError.js'\nimport type {Path} from './paths.js'\n\nconst idPattern = /^[a-z0-9][a-z0-9_.-]+$/i\nconst propPattern = /^[a-zA-Z_][a-zA-Z0-9_-]*$/\nconst propStartPattern = /^[a-z_]/i\n\n/**\n * Validate the given document/subtree for Sanity compatibility\n *\n * @param item - The document or subtree to validate\n * @param path - The path to the current item, for error reporting\n * @returns True if valid, throws otherwise\n * @internal\n */\nexport function validateDocument(item: unknown, path: Path = []): boolean {\n  if (Array.isArray(item)) {\n    return item.every((child, i) => {\n      if (Array.isArray(child)) {\n        throw new DiffError('Multi-dimensional arrays not supported', path.concat(i))\n      }\n\n      return validateDocument(child, path.concat(i))\n    })\n  }\n\n  if (typeof item === 'object' && item !== null) {\n    const obj = item as {[key: string]: any}\n    return Object.keys(obj).every(\n      (key) =>\n        validateProperty(key, obj[key], path) && validateDocument(obj[key], path.concat(key)),\n    )\n  }\n\n  return true\n}\n\n/**\n * Validate a property for Sanity compatibility\n *\n * @param property - The property to valide\n * @param value - The value of the property\n * @param path - The path of the property, for error reporting\n * @returns The property name, if valid\n * @internal\n */\nexport function validateProperty(property: string, value: unknown, path: Path): string {\n  if (!propStartPattern.test(property)) {\n    throw new DiffError('Keys must start with a letter (a-z)', path.concat(property), value)\n  }\n\n  if (!propPattern.test(property)) {\n    throw new DiffError(\n      'Keys can only contain letters, numbers and underscores',\n      path.concat(property),\n      value,\n    )\n  }\n\n  if (property === '_key' || property === '_ref' || property === '_type') {\n    if (typeof value !== 'string') {\n      throw new DiffError('Keys must be strings', path.concat(property), value)\n    }\n\n    if (!idPattern.test(value)) {\n      throw new DiffError('Invalid key - use less exotic characters', path.concat(property), value)\n    }\n  }\n\n  return property\n}\n","import {cleanupEfficiency, makeDiff, makePatches, stringifyPatches} from '@sanity/diff-match-patch'\nimport {DiffError} from './diffError.js'\nimport {type Path, pathToString} from './paths.js'\nimport {validateProperty} from './validate.js'\nimport {\n  type Patch,\n  type SetPatch,\n  type UnsetPatch,\n  type InsertAfterPatch,\n  type DiffMatchPatch,\n  type SanityInsertPatch,\n  type SanityPatch,\n  type SanitySetPatch,\n  type SanityUnsetPatch,\n  type SanityDiffMatchPatch,\n  type SanityPatchMutation,\n} from './patches.js'\n\nconst ignoredKeys = ['_id', '_type', '_createdAt', '_updatedAt', '_rev']\n\ntype PrimitiveValue = string | number | boolean | null | undefined\n\n/**\n * An object (record) that has a `_key` property\n *\n * @internal\n */\nexport interface KeyedSanityObject {\n  [key: string]: unknown\n  _key: string\n}\n\n/**\n * An object (record) that _may_ have a `_key` property\n *\n * @internal\n */\nexport type SanityObject = KeyedSanityObject | Partial<KeyedSanityObject>\n\n/**\n * Represents a partial Sanity document (eg a \"stub\").\n *\n * @public\n */\nexport interface DocumentStub {\n  _id?: string\n  _type?: string\n  _rev?: string\n  _createdAt?: string\n  _updatedAt?: string\n  [key: string]: unknown\n}\n\n/**\n * Options for the diff-match-patch algorithm.\n *\n * @public\n */\nexport interface DiffMatchPatchOptions {\n  /**\n   * Whether or not to use diff-match-patch at all\n   *\n   * @defaultValue `true`\n   */\n  enabled: boolean\n\n  /**\n   * Threshold at which to start using diff-match-patch instead of a regular `set` patch.\n   *\n   * @defaultValue `30`\n   */\n  lengthThresholdAbsolute: number\n\n  /**\n   * Only use generated diff-match-patch if the patch length is less than or equal to\n   * (targetString * relative). Example: A 100 character target with a relative factor\n   * of 1.2 will allow a 120 character diff-match-patch. If larger than this number,\n   * it will fall back to a regular `set` patch.\n   *\n   * @defaultValue `1.2`\n   */\n  lengthThresholdRelative: number\n}\n\n/**\n * Options for the patch generator\n *\n * @public\n */\nexport interface PatchOptions {\n  /**\n   * Document ID to apply the patch to.\n   *\n   * @defaultValue `undefined` - tries to extract `_id` from passed document\n   */\n  id?: string\n\n  /**\n   * Base path to apply the patch to - useful if diffing sub-branches of a document.\n   *\n   * @defaultValue `[]` - eg root of the document\n   */\n  basePath?: Path\n\n  /**\n   * Only apply the patch if the document revision matches this value.\n   * If the property is the boolean value `true`, it will attempt to extract\n   * the revision from the document `_rev` property.\n   *\n   * @defaultValue `undefined` (do not apply revision check)\n   */\n  ifRevisionID?: string | true\n\n  /**\n   * Whether or not to hide warnings during the diff process.\n   *\n   * @defaultValue `false`\n   */\n  hideWarnings?: boolean\n\n  /**\n   * Options for the diff-match-patch algorithm.\n   */\n  diffMatchPatch?: Partial<DiffMatchPatchOptions>\n}\n\n/**\n * Options for diff generation, where all DMP properties are required\n *\n * @public\n */\nexport type DiffOptions = PatchOptions & {diffMatchPatch: Required<DiffMatchPatchOptions>}\n\nconst defaultOptions = {\n  hideWarnings: false,\n  diffMatchPatch: {\n    enabled: true,\n\n    // Only use diff-match-patch if target string is longer than this threshold\n    lengthThresholdAbsolute: 30,\n\n    // Only use generated diff-match-patch if the patch length is less than or equal to\n    // (targetString * relative). Example: A 100 character target with a relative factor\n    // of 1.2 will allow a 120 character diff-match-patch. If larger than this number,\n    // it will fall back to a regular `set` patch.\n    lengthThresholdRelative: 1.2,\n  },\n} satisfies DiffOptions\n\n/**\n * Merges the default options with the passed in options.\n *\n * @param options - Options to merge with the defaults\n * @returns Merged options\n */\nfunction mergeOptions(options: PatchOptions): DiffOptions {\n  return {\n    ...defaultOptions,\n    ...options,\n    diffMatchPatch: {...defaultOptions.diffMatchPatch, ...(options.diffMatchPatch || {})},\n  }\n}\n\n/**\n * Generates an array of mutations for Sanity, based on the differences between\n * the two passed documents/trees.\n *\n * @param itemA - The first document/tree to compare\n * @param itemB - The second document/tree to compare\n * @param opts - Options for the diff generation\n * @returns Array of mutations\n * @public\n */\nexport function diffPatch(\n  itemA: DocumentStub,\n  itemB: DocumentStub,\n  opts?: PatchOptions,\n): SanityPatchMutation[] {\n  const options = mergeOptions(opts || {})\n  const id = options.id || (itemA._id === itemB._id && itemA._id)\n  const revisionLocked = options.ifRevisionID\n  const ifRevisionID = typeof revisionLocked === 'boolean' ? itemA._rev : revisionLocked\n  const basePath = options.basePath || []\n  if (!id) {\n    throw new Error(\n      '_id on itemA and itemB not present or differs, specify document id the mutations should be applied to',\n    )\n  }\n\n  if (revisionLocked === true && !ifRevisionID) {\n    throw new Error(\n      '`ifRevisionID` is set to `true`, but no `_rev` was passed in item A. Either explicitly set `ifRevisionID` to a revision, or pass `_rev` as part of item A.',\n    )\n  }\n\n  if (basePath.length === 0 && itemA._type !== itemB._type) {\n    throw new Error(`_type is immutable and cannot be changed (${itemA._type} => ${itemB._type})`)\n  }\n\n  const operations = diffItem(itemA, itemB, options, basePath, [])\n  return serializePatches(operations, {id, ifRevisionID: revisionLocked ? ifRevisionID : undefined})\n}\n\n/**\n * Diffs two items and returns an array of patches.\n * Note that this is different from `diffPatch`, which generates _mutations_.\n *\n * @param itemA - The first item to compare\n * @param itemB - The second item to compare\n * @param opts - Options for the diff generation\n * @param path - Path to the current item\n * @param patches - Array of patches to append the results to. Note that this is MUTATED.\n * @returns Array of patches\n * @public\n */\nexport function diffItem(\n  itemA: unknown,\n  itemB: unknown,\n  opts: DiffOptions = defaultOptions,\n  path: Path = [],\n  patches: Patch[] = [],\n): Patch[] {\n  if (itemA === itemB) {\n    return patches\n  }\n\n  const aType = Array.isArray(itemA) ? 'array' : typeof itemA\n  const bType = Array.isArray(itemB) ? 'array' : typeof itemB\n\n  const aIsUndefined = aType === 'undefined'\n  const bIsUndefined = bType === 'undefined'\n\n  if (aIsUndefined && !bIsUndefined) {\n    patches.push({op: 'set', path, value: itemB})\n    return patches\n  }\n\n  if (!aIsUndefined && bIsUndefined) {\n    patches.push({op: 'unset', path})\n    return patches\n  }\n\n  const options = mergeOptions(opts)\n  const dataType = aIsUndefined ? bType : aType\n  const isContainer = dataType === 'object' || dataType === 'array'\n  if (!isContainer) {\n    return diffPrimitive(itemA as PrimitiveValue, itemB as PrimitiveValue, options, path, patches)\n  }\n\n  if (aType !== bType) {\n    // Array => Object / Object => Array\n    patches.push({op: 'set', path, value: itemB})\n    return patches\n  }\n\n  return dataType === 'array'\n    ? diffArray(itemA as unknown[], itemB as unknown[], options, path, patches)\n    : diffObject(itemA as object, itemB as object, options, path, patches)\n}\n\nfunction diffObject(\n  itemA: SanityObject,\n  itemB: SanityObject,\n  options: DiffOptions,\n  path: Path,\n  patches: Patch[],\n) {\n  const atRoot = path.length === 0\n  const aKeys = Object.keys(itemA)\n    .filter(atRoot ? isNotIgnoredKey : yes)\n    .map((key) => validateProperty(key, itemA[key], path))\n\n  const aKeysLength = aKeys.length\n  const bKeys = Object.keys(itemB)\n    .filter(atRoot ? isNotIgnoredKey : yes)\n    .map((key) => validateProperty(key, itemB[key], path))\n\n  const bKeysLength = bKeys.length\n\n  // Check for deleted items\n  for (let i = 0; i < aKeysLength; i++) {\n    const key = aKeys[i]\n    if (!(key in itemB)) {\n      patches.push({op: 'unset', path: path.concat(key)})\n    }\n  }\n\n  // Check for changed items\n  for (let i = 0; i < bKeysLength; i++) {\n    const key = bKeys[i]\n    diffItem(itemA[key], itemB[key], options, path.concat([key]), patches)\n  }\n\n  return patches\n}\n\nfunction diffArray(\n  itemA: unknown[],\n  itemB: unknown[],\n  options: DiffOptions,\n  path: Path,\n  patches: Patch[],\n) {\n  // Check for new items\n  if (itemB.length > itemA.length) {\n    patches.push({\n      op: 'insert',\n      after: path.concat([-1]),\n      items: itemB.slice(itemA.length).map((item, i) => nullifyUndefined(item, path, i, options)),\n    })\n  }\n\n  // Check for deleted items\n  if (itemB.length < itemA.length) {\n    const isSingle = itemA.length - itemB.length === 1\n    const unsetItems = itemA.slice(itemB.length)\n\n    // If we're revision locked, we can safely unset ranges (eg 5:<end-of-array>).\n    // Also, if we don't have unique array keys, we can't use any better approach\n    // than array indexes. If we _do_ have unique array keys, we'll want to unset\n    // by key, as this is safer in a realtime, collaborative setting\n    if (isRevisionLocked(options) || !isUniquelyKeyed(unsetItems)) {\n      patches.push({\n        op: 'unset',\n        path: path.concat([isSingle ? itemB.length : [itemB.length, '']]),\n      })\n    } else {\n      patches.push(\n        ...unsetItems.map(\n          (item): UnsetPatch => ({op: 'unset', path: path.concat({_key: item._key})}),\n        ),\n      )\n    }\n  }\n\n  // Check for illegal array contents\n  for (let i = 0; i < itemB.length; i++) {\n    if (Array.isArray(itemB[i])) {\n      throw new DiffError('Multi-dimensional arrays not supported', path.concat(i), itemB[i])\n    }\n  }\n\n  const overlapping = Math.min(itemA.length, itemB.length)\n  const segmentA = itemA.slice(0, overlapping)\n  const segmentB = itemB.slice(0, overlapping)\n\n  return isUniquelyKeyed(segmentA) && isUniquelyKeyed(segmentB)\n    ? diffArrayByKey(segmentA, segmentB, options, path, patches)\n    : diffArrayByIndex(segmentA, segmentB, options, path, patches)\n}\n\nfunction diffArrayByIndex(\n  itemA: unknown[],\n  itemB: unknown[],\n  options: DiffOptions,\n  path: Path,\n  patches: Patch[],\n) {\n  for (let i = 0; i < itemA.length; i++) {\n    diffItem(\n      itemA[i],\n      nullifyUndefined(itemB[i], path, i, options),\n      options,\n      path.concat(i),\n      patches,\n    )\n  }\n\n  return patches\n}\n\nfunction diffArrayByKey(\n  itemA: KeyedSanityObject[],\n  itemB: KeyedSanityObject[],\n  options: DiffOptions,\n  path: Path,\n  patches: Patch[],\n) {\n  const keyedA = indexByKey(itemA)\n  const keyedB = indexByKey(itemB)\n\n  // There's a bunch of hard/semi-hard problems related to using keys\n  // Unless we have the exact same order, just use indexes for now\n  if (!arrayIsEqual(keyedA.keys, keyedB.keys)) {\n    return diffArrayByIndex(itemA, itemB, options, path, patches)\n  }\n\n  for (let i = 0; i < keyedB.keys.length; i++) {\n    const key = keyedB.keys[i]\n    const valueA = keyedA.index[key]\n    const valueB = nullifyUndefined(keyedB.index[key], path, i, options)\n    diffItem(valueA, valueB, options, path.concat({_key: key}), patches)\n  }\n\n  return patches\n}\n\nfunction getDiffMatchPatch(\n  itemA: PrimitiveValue,\n  itemB: PrimitiveValue,\n  options: DiffOptions,\n  path: Path,\n): DiffMatchPatch | undefined {\n  const {enabled, lengthThresholdRelative, lengthThresholdAbsolute} = options.diffMatchPatch\n  const segment = path[path.length - 1]\n  if (\n    !enabled ||\n    // Don't use for anything but strings\n    typeof itemA !== 'string' ||\n    typeof itemB !== 'string' ||\n    // Don't use for `_key`, `_ref` etc\n    (typeof segment === 'string' && segment[0] === '_') ||\n    // Don't use on short strings\n    itemB.length < lengthThresholdAbsolute\n  ) {\n    return undefined\n  }\n\n  let strPatch = ''\n  try {\n    const patch = makeDiff(itemA, itemB)\n    const diff = cleanupEfficiency(patch)\n    strPatch = stringifyPatches(makePatches(diff))\n  } catch (err) {\n    // Fall back to using regular set patch\n    return undefined\n  }\n\n  // Don't use patch if it's longer than allowed relative threshold.\n  // Allow a 120 character patch for a 100 character string,\n  // but don't allow a 800 character patch for a 500 character value.\n  return strPatch.length > itemB.length * lengthThresholdRelative\n    ? undefined\n    : {op: 'diffMatchPatch', path, value: strPatch}\n}\n\nfunction diffPrimitive(\n  itemA: PrimitiveValue,\n  itemB: PrimitiveValue,\n  options: DiffOptions,\n  path: Path,\n  patches: Patch[],\n): Patch[] {\n  const dmp = getDiffMatchPatch(itemA, itemB, options, path)\n\n  patches.push(\n    dmp || {\n      op: 'set',\n      path,\n      value: itemB,\n    },\n  )\n\n  return patches\n}\n\nfunction isNotIgnoredKey(key: string) {\n  return ignoredKeys.indexOf(key) === -1\n}\n\nfunction serializePatches(\n  patches: Patch[],\n  options: {id: string; ifRevisionID?: string},\n): SanityPatchMutation[] {\n  if (patches.length === 0) {\n    return []\n  }\n\n  const {id, ifRevisionID} = options\n  const set = patches.filter((patch): patch is SetPatch => patch.op === 'set')\n  const unset = patches.filter((patch): patch is UnsetPatch => patch.op === 'unset')\n  const insert = patches.filter((patch): patch is InsertAfterPatch => patch.op === 'insert')\n  const dmp = patches.filter((patch): patch is DiffMatchPatch => patch.op === 'diffMatchPatch')\n\n  const withSet =\n    set.length > 0 &&\n    set.reduce(\n      (patch: SanitySetPatch, item: SetPatch) => {\n        const path = pathToString(item.path)\n        patch.set[path] = item.value\n        return patch\n      },\n      {id, set: {}},\n    )\n\n  const withUnset =\n    unset.length > 0 &&\n    unset.reduce(\n      (patch: SanityUnsetPatch, item: UnsetPatch) => {\n        const path = pathToString(item.path)\n        patch.unset.push(path)\n        return patch\n      },\n      {id, unset: []},\n    )\n\n  const withInsert = insert.reduce((acc: SanityInsertPatch[], item: InsertAfterPatch) => {\n    const after = pathToString(item.after)\n    return acc.concat({id, insert: {after, items: item.items}})\n  }, [])\n\n  const withDmp =\n    dmp.length > 0 &&\n    dmp.reduce(\n      (patch: SanityDiffMatchPatch, item: DiffMatchPatch) => {\n        const path = pathToString(item.path)\n        patch.diffMatchPatch[path] = item.value\n        return patch\n      },\n      {id, diffMatchPatch: {}},\n    )\n\n  const patchSet: SanityPatch[] = [withUnset, withSet, withDmp, ...withInsert].filter(\n    (item): item is SanityPatch => item !== false,\n  )\n\n  return patchSet.map((patch, i) => ({\n    patch: ifRevisionID && i === 0 ? {...patch, ifRevisionID} : patch,\n  }))\n}\n\nfunction isUniquelyKeyed(arr: unknown[]): arr is KeyedSanityObject[] {\n  const keys = []\n\n  for (let i = 0; i < arr.length; i++) {\n    const key = getKey(arr[i])\n    if (!key || keys.indexOf(key) !== -1) {\n      return false\n    }\n\n    keys.push(key)\n  }\n\n  return true\n}\n\nfunction getKey(obj: unknown) {\n  return typeof obj === 'object' && obj !== null && (obj as KeyedSanityObject)._key\n}\n\nfunction indexByKey(arr: KeyedSanityObject[]) {\n  return arr.reduce(\n    (acc, item) => {\n      acc.keys.push(item._key)\n      acc.index[item._key] = item\n      return acc\n    },\n    {keys: [] as string[], index: {} as {[key: string]: KeyedSanityObject}},\n  )\n}\n\nfunction arrayIsEqual(itemA: unknown[], itemB: unknown[]) {\n  return itemA.length === itemB.length && itemA.every((item, i) => itemB[i] === item)\n}\n\nfunction nullifyUndefined(item: unknown, path: Path, index: number, options: PatchOptions) {\n  if (typeof item !== 'undefined') {\n    return item\n  }\n\n  if (!options.hideWarnings) {\n    const serializedPath = pathToString(path.concat(index))\n    console.warn(`undefined value in array converted to null (at '${serializedPath}')`)\n  }\n\n  return null\n}\n\nfunction isRevisionLocked(options: PatchOptions): boolean {\n  return Boolean(options.ifRevisionID)\n}\n\nfunction yes(_: unknown) {\n  return true\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/paths.ts","../src/diffError.ts","../src/validate.ts","../src/setOperations.ts","../src/diffPatch.ts"],"sourcesContent":["const IS_DOTTABLE_RE = /^[A-Za-z_][A-Za-z0-9_]*$/\n\n/**\n * A segment of a path\n *\n * @public\n */\nexport type PathSegment =\n  | string // Property\n  | number // Array index\n  | {_key: string} // Array `_key` lookup\n  | [number | '', number | ''] // From/to array index\n\n/**\n * An array of path segments representing a path in a document\n *\n * @public\n */\nexport type Path = PathSegment[]\n\n/**\n * Converts an array path to a string path\n *\n * @param path - The array path to convert\n * @returns A stringified path\n * @internal\n */\nexport function pathToString(path: Path): string {\n  return path.reduce((target: string, segment: PathSegment, i: number) => {\n    if (Array.isArray(segment)) {\n      return `${target}[${segment.join(':')}]`\n    }\n\n    if (isKeyedObject(segment)) {\n      return `${target}[_key==\"${segment._key}\"]`\n    }\n\n    if (typeof segment === 'number') {\n      return `${target}[${segment}]`\n    }\n\n    if (typeof segment === 'string' && !IS_DOTTABLE_RE.test(segment)) {\n      return `${target}['${segment}']`\n    }\n\n    if (typeof segment === 'string') {\n      const separator = i === 0 ? '' : '.'\n      return `${target}${separator}${segment}`\n    }\n\n    throw new Error(`Unsupported path segment \"${segment}\"`)\n  }, '')\n}\n\n/**\n * An object (record) that has a `_key` property\n *\n * @internal\n */\nexport interface KeyedSanityObject {\n  [key: string]: unknown\n  _key: string\n}\n\nexport function isKeyedObject(obj: unknown): obj is KeyedSanityObject {\n  return typeof obj === 'object' && !!obj && '_key' in obj && typeof obj._key === 'string'\n}\n","import {type Path, pathToString} from './paths.js'\n\n/**\n * Represents an error that occurred during a diff process.\n * Contains `path`, `value` and `serializedPath` properties,\n * which is helpful for debugging and showing friendly messages.\n *\n * @public\n */\nexport class DiffError extends Error {\n  public path: Path\n  public value: unknown\n  public serializedPath: string\n\n  constructor(message: string, path: Path, value?: unknown) {\n    const serializedPath = pathToString(path)\n    super(`${message} (at '${serializedPath}')`)\n\n    this.path = path\n    this.serializedPath = serializedPath\n    this.value = value\n  }\n}\n","import {DiffError} from './diffError.js'\nimport type {Path} from './paths.js'\n\nconst idPattern = /^[a-z0-9][a-z0-9_.-]+$/i\nconst propPattern = /^[a-zA-Z_][a-zA-Z0-9_-]*$/\nconst propStartPattern = /^[a-z_]/i\n\n/**\n * Validate the given document/subtree for Sanity compatibility\n *\n * @param item - The document or subtree to validate\n * @param path - The path to the current item, for error reporting\n * @returns True if valid, throws otherwise\n * @internal\n */\nexport function validateDocument(item: unknown, path: Path = []): boolean {\n  if (Array.isArray(item)) {\n    return item.every((child, i) => {\n      if (Array.isArray(child)) {\n        throw new DiffError('Multi-dimensional arrays not supported', path.concat(i))\n      }\n\n      return validateDocument(child, path.concat(i))\n    })\n  }\n\n  if (typeof item === 'object' && item !== null) {\n    const obj = item as {[key: string]: any}\n    return Object.keys(obj).every(\n      (key) =>\n        validateProperty(key, obj[key], path) && validateDocument(obj[key], path.concat(key)),\n    )\n  }\n\n  return true\n}\n\n/**\n * Validate a property for Sanity compatibility\n *\n * @param property - The property to valide\n * @param value - The value of the property\n * @param path - The path of the property, for error reporting\n * @returns The property name, if valid\n * @internal\n */\nexport function validateProperty(property: string, value: unknown, path: Path): string {\n  if (!propStartPattern.test(property)) {\n    throw new DiffError('Keys must start with a letter (a-z)', path.concat(property), value)\n  }\n\n  if (!propPattern.test(property)) {\n    throw new DiffError(\n      'Keys can only contain letters, numbers and underscores',\n      path.concat(property),\n      value,\n    )\n  }\n\n  if (property === '_key' || property === '_ref' || property === '_type') {\n    if (typeof value !== 'string') {\n      throw new DiffError('Keys must be strings', path.concat(property), value)\n    }\n\n    if (!idPattern.test(value)) {\n      throw new DiffError('Invalid key - use less exotic characters', path.concat(property), value)\n    }\n  }\n\n  return property\n}\n","/// <reference lib=\"esnext\" />\n\nexport function difference<T>(source: Set<T>, target: Set<T>): Set<T> {\n  if ('difference' in Set.prototype) {\n    return source.difference(target)\n  }\n\n  const result = new Set<T>()\n  for (const item of source) {\n    if (!target.has(item)) {\n      result.add(item)\n    }\n  }\n  return result\n}\n\nexport function intersection<T>(source: Set<T>, target: Set<T>): Set<T> {\n  if ('intersection' in Set.prototype) {\n    return source.intersection(target)\n  }\n\n  const result = new Set<T>()\n  for (const item of source) {\n    if (target.has(item)) {\n      result.add(item)\n    }\n  }\n  return result\n}\n","import {makePatches, stringifyPatches} from '@sanity/diff-match-patch'\nimport {DiffError} from './diffError.js'\nimport {isKeyedObject, type KeyedSanityObject, type Path, pathToString} from './paths.js'\nimport {validateProperty} from './validate.js'\nimport {\n  type Patch,\n  type UnsetPatch,\n  type DiffMatchPatch,\n  type SanityPatchMutation,\n  type SanityPatchOperations,\n  type SanitySetPatchOperation,\n  type SanityUnsetPatchOperation,\n  type SanityInsertPatchOperation,\n  type SanityDiffMatchPatchOperation,\n} from './patches.js'\nimport {difference, intersection} from './setOperations.js'\n\n/**\n * Document keys that are ignored during diff operations.\n * These are system-managed fields that should not be included in patches on\n * top-level documents and should not be diffed with diff-match-patch.\n */\nconst SYSTEM_KEYS = ['_id', '_type', '_createdAt', '_updatedAt', '_rev']\n\n/**\n * Maximum size of strings to consider for diff-match-patch (1MB)\n * Based on testing showing consistently good performance up to this size\n */\nconst DMP_MAX_STRING_SIZE = 1_000_000\n\n/**\n * Maximum difference in string length before falling back to set operations (40%)\n * Above this threshold, likely indicates text replacement which can be slow\n */\nconst DMP_MAX_STRING_LENGTH_CHANGE_RATIO = 0.4\n\n/**\n * Minimum string size to apply change ratio check (10KB)\n * Small strings are always fast regardless of change ratio\n */\nconst DMP_MIN_SIZE_FOR_RATIO_CHECK = 10_000\n\n/**\n * Represents a partial Sanity document (eg a \"stub\").\n *\n * @public\n */\nexport interface DocumentStub {\n  _id?: string\n  _type?: string\n  _rev?: string\n  _createdAt?: string\n  _updatedAt?: string\n  [key: string]: unknown\n}\n\n/**\n * Options for the patch generator\n *\n * @public\n */\nexport interface PatchOptions {\n  /**\n   * Document ID to apply the patch to.\n   *\n   * @defaultValue `undefined` - tries to extract `_id` from passed document\n   */\n  id?: string\n\n  /**\n   * Base path to apply the patch to - useful if diffing sub-branches of a document.\n   *\n   * @defaultValue `[]` - eg root of the document\n   */\n  basePath?: Path\n\n  /**\n   * Only apply the patch if the document revision matches this value.\n   * If the property is the boolean value `true`, it will attempt to extract\n   * the revision from the document `_rev` property.\n   *\n   * @defaultValue `undefined` (do not apply revision check)\n   */\n  ifRevisionID?: string | true\n}\n\n/**\n * Generates an array of mutations for Sanity, based on the differences between\n * the two passed documents/trees.\n *\n * @param source - The first document/tree to compare\n * @param target - The second document/tree to compare\n * @param opts - Options for the diff generation\n * @returns Array of mutations\n * @public\n */\nexport function diffPatch(\n  source: DocumentStub,\n  target: DocumentStub,\n  options: PatchOptions = {},\n): SanityPatchMutation[] {\n  const id = options.id || (source._id === target._id && source._id)\n  const revisionLocked = options.ifRevisionID\n  const ifRevisionID = typeof revisionLocked === 'boolean' ? source._rev : revisionLocked\n  const basePath = options.basePath || []\n  if (!id) {\n    throw new Error(\n      '_id on source and target not present or differs, specify document id the mutations should be applied to',\n    )\n  }\n\n  if (revisionLocked === true && !ifRevisionID) {\n    throw new Error(\n      '`ifRevisionID` is set to `true`, but no `_rev` was passed in item A. Either explicitly set `ifRevisionID` to a revision, or pass `_rev` as part of item A.',\n    )\n  }\n\n  if (basePath.length === 0 && source._type !== target._type) {\n    throw new Error(`_type is immutable and cannot be changed (${source._type} => ${target._type})`)\n  }\n\n  const operations = diffItem(source, target, basePath, [])\n  return serializePatches(operations).map((patchOperations, i) => ({\n    patch: {\n      id,\n      // only add `ifRevisionID` to the first patch\n      ...(i === 0 && ifRevisionID && {ifRevisionID}),\n      ...patchOperations,\n    },\n  }))\n}\n\n/**\n * Generates an array of patch operation objects for Sanity, based on the\n * differences between the two passed values\n *\n * @param source - The source value to start off with\n * @param target - The target value that the patch operations will aim to create\n * @param basePath - An optional path that will be prefixed to all subsequent patch operations\n * @returns Array of mutations\n * @public\n */\nexport function diffValue(\n  source: unknown,\n  target: unknown,\n  basePath: Path = [],\n): SanityPatchOperations[] {\n  return serializePatches(diffItem(source, target, basePath))\n}\n\nfunction diffItem(\n  source: unknown,\n  target: unknown,\n  path: Path = [],\n  patches: Patch[] = [],\n): Patch[] {\n  if (source === target) {\n    return patches\n  }\n\n  if (typeof source === 'string' && typeof target === 'string') {\n    diffString(source, target, path, patches)\n    return patches\n  }\n\n  if (Array.isArray(source) && Array.isArray(target)) {\n    diffArray(source, target, path, patches)\n    return patches\n  }\n\n  if (isRecord(source) && isRecord(target)) {\n    diffObject(source, target, path, patches)\n    return patches\n  }\n\n  if (target === undefined) {\n    patches.push({op: 'unset', path})\n    return patches\n  }\n\n  patches.push({op: 'set', path, value: target})\n  return patches\n}\n\nfunction diffObject(\n  source: Record<string, unknown>,\n  target: Record<string, unknown>,\n  path: Path,\n  patches: Patch[],\n) {\n  const atRoot = path.length === 0\n  const aKeys = Object.keys(source)\n    .filter(atRoot ? isNotIgnoredKey : yes)\n    .map((key) => validateProperty(key, source[key], path))\n\n  const aKeysLength = aKeys.length\n  const bKeys = Object.keys(target)\n    .filter(atRoot ? isNotIgnoredKey : yes)\n    .map((key) => validateProperty(key, target[key], path))\n\n  const bKeysLength = bKeys.length\n\n  // Check for deleted items\n  for (let i = 0; i < aKeysLength; i++) {\n    const key = aKeys[i]\n    if (!(key in target)) {\n      patches.push({op: 'unset', path: path.concat(key)})\n    }\n  }\n\n  // Check for changed items\n  for (let i = 0; i < bKeysLength; i++) {\n    const key = bKeys[i]\n    diffItem(source[key], target[key], path.concat([key]), patches)\n  }\n\n  return patches\n}\n\nfunction diffArray(source: unknown[], target: unknown[], path: Path, patches: Patch[]) {\n  if (isUniquelyKeyed(source) && isUniquelyKeyed(target)) {\n    return diffArrayByKey(source, target, path, patches)\n  }\n\n  return diffArrayByIndex(source, target, path, patches)\n}\n\nfunction diffArrayByIndex(source: unknown[], target: unknown[], path: Path, patches: Patch[]) {\n  // Check for new items\n  if (target.length > source.length) {\n    patches.push({\n      op: 'insert',\n      position: 'after',\n      path: path.concat([-1]),\n      items: target.slice(source.length).map(nullifyUndefined),\n    })\n  }\n\n  // Check for deleted items\n  if (target.length < source.length) {\n    const isSingle = source.length - target.length === 1\n    const unsetItems = source.slice(target.length)\n\n    // If we have unique array keys, we'll want to unset by key, as this is\n    // safer in a realtime, collaborative setting\n    if (isUniquelyKeyed(unsetItems)) {\n      patches.push(\n        ...unsetItems.map((item): UnsetPatch => ({\n          op: 'unset',\n          path: path.concat({_key: item._key}),\n        })),\n      )\n    } else {\n      patches.push({\n        op: 'unset',\n        path: path.concat([isSingle ? target.length : [target.length, '']]),\n      })\n    }\n  }\n\n  // Check for illegal array contents\n  for (let i = 0; i < target.length; i++) {\n    if (Array.isArray(target[i])) {\n      throw new DiffError('Multi-dimensional arrays not supported', path.concat(i), target[i])\n    }\n  }\n\n  const overlapping = Math.min(source.length, target.length)\n  const segmentA = source.slice(0, overlapping)\n  const segmentB = target.slice(0, overlapping)\n\n  for (let i = 0; i < segmentA.length; i++) {\n    diffItem(segmentA[i], nullifyUndefined(segmentB[i]), path.concat(i), patches)\n  }\n\n  return patches\n}\n\n/**\n * Diffs two arrays of keyed objects by their `_key` properties.\n *\n * This approach is preferred over index-based diffing for collaborative editing scenarios\n * because it generates patches that are more resilient to concurrent modifications.\n * When multiple users edit the same array simultaneously, key-based patches have better\n * conflict resolution characteristics than index-based patches.\n *\n * The function handles three main operations:\n * 1. **Reordering**: When existing items change positions within the array\n * 2. **Content changes**: When the content of existing items is modified\n * 3. **Insertions/Deletions**: When items are added or removed from the array\n *\n * @param source - The original array with keyed objects\n * @param target - The target array with keyed objects\n * @param path - The path to this array within the document\n * @param patches - Array to accumulate generated patches\n * @returns The patches array with new patches appended\n */\nfunction diffArrayByKey(\n  source: KeyedSanityObject[],\n  target: KeyedSanityObject[],\n  path: Path,\n  patches: Patch[],\n) {\n  // Create lookup maps for efficient key-based access to array items\n  const sourceItemsByKey = new Map(source.map((item) => [item._key, item]))\n  const targetItemsByKey = new Map(target.map((item) => [item._key, item]))\n\n  // Categorize keys by their presence in source vs target arrays\n  const sourceKeys = new Set(sourceItemsByKey.keys())\n  const targetKeys = new Set(targetItemsByKey.keys())\n  const keysRemovedFromSource = difference(sourceKeys, targetKeys)\n  const keysAddedToTarget = difference(targetKeys, sourceKeys)\n  const keysInBothArrays = intersection(sourceKeys, targetKeys)\n\n  // Handle reordering of existing items within the array.\n  // We detect reordering by comparing the relative positions of keys that exist in both arrays,\n  // excluding keys that were added or removed (since they don't participate in reordering).\n  const sourceKeysStillPresent = Array.from(difference(sourceKeys, keysRemovedFromSource))\n  const targetKeysAlreadyPresent = Array.from(difference(targetKeys, keysAddedToTarget))\n\n  // Track which keys need to be reordered by comparing their relative positions\n  const keyReorderOperations: {sourceKey: string; targetKey: string}[] = []\n\n  for (let i = 0; i < keysInBothArrays.size; i++) {\n    const keyAtPositionInSource = sourceKeysStillPresent[i]\n    const keyAtPositionInTarget = targetKeysAlreadyPresent[i]\n\n    // If different keys occupy the same relative position, a reorder is needed\n    if (keyAtPositionInSource !== keyAtPositionInTarget) {\n      keyReorderOperations.push({\n        sourceKey: keyAtPositionInSource,\n        targetKey: keyAtPositionInTarget,\n      })\n    }\n  }\n\n  // Generate reorder patch if any items changed positions\n  if (keyReorderOperations.length) {\n    patches.push({\n      op: 'reorder',\n      path,\n      snapshot: source,\n      reorders: keyReorderOperations,\n    })\n  }\n\n  // Process content changes for items that exist in both arrays\n  for (const key of keysInBothArrays) {\n    diffItem(sourceItemsByKey.get(key), targetItemsByKey.get(key), [...path, {_key: key}], patches)\n  }\n\n  // Remove items that no longer exist in the target array\n  for (const keyToRemove of keysRemovedFromSource) {\n    patches.push({op: 'unset', path: [...path, {_key: keyToRemove}]})\n  }\n\n  // Insert new items that were added to the target array\n  // We batch consecutive insertions for efficiency and insert them at the correct positions\n  if (keysAddedToTarget.size) {\n    let insertionAnchorKey: string // The key after which we'll insert pending items\n    let itemsPendingInsertion: unknown[] = []\n\n    const flushPendingInsertions = () => {\n      if (itemsPendingInsertion.length) {\n        patches.push({\n          op: 'insert',\n          // Insert after the anchor key if we have one, otherwise insert at the beginning\n          ...(insertionAnchorKey\n            ? {position: 'after', path: [...path, {_key: insertionAnchorKey}]}\n            : {position: 'before', path: [...path, 0]}),\n          items: itemsPendingInsertion,\n        })\n      }\n    }\n\n    // Walk through the target array to determine where new items should be inserted\n    for (const key of targetKeys) {\n      if (keysAddedToTarget.has(key)) {\n        // This is a new item - add it to the pending insertion batch\n        itemsPendingInsertion.push(targetItemsByKey.get(key)!)\n      } else if (keysInBothArrays.has(key)) {\n        // This is an existing item - flush any pending insertions before it\n        flushPendingInsertions()\n        insertionAnchorKey = key\n        itemsPendingInsertion = []\n      }\n    }\n\n    // Flush any remaining insertions at the end\n    flushPendingInsertions()\n  }\n\n  return patches\n}\n\n/**\n * Determines whether to use diff-match-patch or fallback to a `set` operation\n * when creating a patch to transform a `source` string to `target` string.\n *\n * `diffMatchPatch` patches are typically preferred to `set` operations because\n * they handle conflicts better (when multiple editors work simultaneously) by\n * preserving the user's intended and allowing for 3-way merges.\n *\n * **Heuristic rationale:**\n *\n * Perf analysis revealed that string length has minimal impact on small,\n * keystroke-level changes, but large text replacements (high change ratio) can\n * trigger worst-case algorithm behavior. The 40% change ratio threshold is a\n * simple heuristic that catches problematic replacement scenarios while\n * allowing the algorithm to excel at insertions and deletions.\n *\n * **Performance characteristics (tested on M2 MacBook Pro):**\n *\n * *Keystroke-level editing (most common use case):*\n * - Small strings (1KB-10KB): 0ms for 1-5 keystrokes, consistently sub-millisecond\n * - Medium strings (50KB-200KB): 0ms for 1-5 keystrokes, consistently sub-millisecond\n * - 10 simultaneous keystrokes: ~12ms on 100KB strings\n *\n * *Copy-paste operations (less frequent):*\n * - Small copy-paste operations (<50KB): 0-10ms regardless of string length\n * - Large insertions/deletions (50KB+): 0-50ms (excellent performance)\n * - Large text replacements (50KB+): 70ms-2s+ (can be slow due to algorithm complexity)\n *\n * **Algorithm details:**\n * Uses Myers' diff algorithm with O(ND) time complexity where N=text length and D=edit distance.\n * Includes optimizations: common prefix/suffix removal, line-mode processing, and timeout protection.\n *\n *\n * **Test methodology:**\n * - Generated realistic word-based text patterns\n * - Simulated actual editing behaviors (keystrokes vs copy-paste)\n * - Measured performance across string sizes from 1KB to 10MB\n * - Validated against edge cases including repetitive text and scattered changes\n *\n * @param source - The previous version of the text\n * @param target - The new version of the text\n * @returns true if diff-match-patch should be used, false if fallback to set operation\n *\n * @example\n * ```typescript\n * // Keystroke editing - always fast\n * shouldUseDiffMatchPatch(largeDoc, largeDocWithTypo) // true, ~0ms\n *\n * // Small paste - always fast\n * shouldUseDiffMatchPatch(doc, docWithSmallInsertion) // true, ~0ms\n *\n * // Large replacement - potentially slow\n * shouldUseDiffMatchPatch(article, completelyDifferentArticle) // false, use set\n * ```\n *\n * Compatible with @sanity/diff-match-patch@3.2.0\n */\nfunction shouldUseDiffMatchPatch(source: string, target: string): boolean {\n  const maxLength = Math.max(source.length, target.length)\n\n  // Always reject strings larger than our tested size limit\n  if (maxLength > DMP_MAX_STRING_SIZE) {\n    return false\n  }\n\n  // For small strings, always use diff-match-patch regardless of change ratio\n  // Performance testing showed these are always fast (<10ms)\n  if (maxLength < DMP_MIN_SIZE_FOR_RATIO_CHECK) {\n    return true\n  }\n\n  // Calculate the change ratio to detect large text replacements\n  // High ratios indicate replacement scenarios which can trigger slow algorithm paths\n  const lengthDifference = Math.abs(target.length - source.length)\n  const changeRatio = lengthDifference / maxLength\n\n  // If change ratio is high, likely a replacement operation that could be slow\n  // Fall back to set operation for better user experience\n  if (changeRatio > DMP_MAX_STRING_LENGTH_CHANGE_RATIO) {\n    return false\n  }\n\n  // All other cases: use diff-match-patch\n  // This covers keystroke editing and insertion/deletion scenarios which perform excellently\n  return true\n}\n\nfunction getDiffMatchPatch(source: string, target: string, path: Path): DiffMatchPatch | undefined {\n  const last = path.at(-1)\n  // don't use diff-match-patch for system keys\n  if (typeof last === 'string' && last.startsWith('_')) return undefined\n  if (!shouldUseDiffMatchPatch(source, target)) return undefined\n\n  try {\n    // Using `makePatches(string, string)` directly instead of the multi-step approach e.g.\n    // `stringifyPatches(makePatches(cleanupEfficiency(makeDiff(source, target))))`.\n    // this is because `makePatches` internally handles diff generation and\n    // automatically applies both `cleanupSemantic()` and `cleanupEfficiency()`\n    // when beneficial, resulting in cleaner code with near identical performance and\n    // better error handling.\n    // [source](https://github.com/sanity-io/diff-match-patch/blob/v3.2.0/src/patch/make.ts#L67-L76)\n    //\n    // Performance validation (M2 MacBook Pro):\n    // Both approaches measured at identical performance:\n    // - 10KB strings: 0-1ms total processing time\n    // - 100KB strings: 0-1ms total processing time\n    // - Individual step breakdown: makeDiff(0ms) + cleanup(0ms) + makePatches(0ms) + stringify(~1ms)\n    const strPatch = stringifyPatches(makePatches(source, target))\n    return {op: 'diffMatchPatch', path, value: strPatch}\n  } catch {\n    // Fall back to using regular set patch\n    return undefined\n  }\n}\n\nfunction diffString(source: string, target: string, path: Path, patches: Patch[]) {\n  const dmp = getDiffMatchPatch(source, target, path)\n  patches.push(dmp ?? {op: 'set', path, value: target})\n  return patches\n}\n\nfunction isNotIgnoredKey(key: string) {\n  return SYSTEM_KEYS.indexOf(key) === -1\n}\n\n// mutually exclusive operations\ntype SanityPatchOperation =\n  | SanitySetPatchOperation\n  | SanityUnsetPatchOperation\n  | SanityInsertPatchOperation\n  | SanityDiffMatchPatchOperation\n\nfunction serializePatches(patches: Patch[], curr?: SanityPatchOperation): SanityPatchOperations[] {\n  const [patch, ...rest] = patches\n  if (!patch) return curr ? [curr] : []\n\n  switch (patch.op) {\n    case 'set':\n    case 'diffMatchPatch': {\n      type CurrentOp = Extract<SanityPatchOperation, {[K in typeof patch.op]: {}}>\n      const emptyOp = {[patch.op]: {}} as CurrentOp\n\n      if (!curr) return serializePatches(patches, emptyOp)\n      if (!(patch.op in curr)) return [curr, ...serializePatches(patches, emptyOp)]\n\n      Object.assign((curr as CurrentOp)[patch.op], {[pathToString(patch.path)]: patch.value})\n      return serializePatches(rest, curr)\n    }\n    case 'unset': {\n      const emptyOp = {unset: []}\n      if (!curr) return serializePatches(patches, emptyOp)\n      if (!('unset' in curr)) return [curr, ...serializePatches(patches, emptyOp)]\n\n      curr.unset.push(pathToString(patch.path))\n      return serializePatches(rest, curr)\n    }\n    case 'insert': {\n      if (curr) return [curr, ...serializePatches(patches)]\n\n      return [\n        {\n          insert: {\n            [patch.position]: pathToString(patch.path),\n            items: patch.items,\n          },\n        } as SanityInsertPatchOperation,\n        ...serializePatches(rest),\n      ]\n    }\n    case 'reorder': {\n      if (curr) return [curr, ...serializePatches(patches)]\n\n      // REORDER STRATEGY: Two-phase approach to avoid key collisions\n      //\n      // Problem: Direct key swaps can cause collisions. For example, swapping A↔B:\n      // - Set A's content to B: ✓\n      // - Set B's content to A: ✗ (A's content was already overwritten)\n      //\n      // Solution: Use temporary keys as an intermediate step\n      // Phase 1: Move all items to temporary keys with their final content\n      // Phase 2: Update just the _key property to restore the final keys\n\n      // Phase 1: Move items to collision-safe temporary keys\n      const tempKeyOperations: SanityPatchOperations = {}\n      tempKeyOperations.set = {}\n\n      for (const {sourceKey, targetKey} of patch.reorders) {\n        const temporaryKey = `__temp_reorder_${sourceKey}__`\n        const finalContentForThisPosition =\n          patch.snapshot[getIndexForKey(patch.snapshot, targetKey)]\n\n        Object.assign(tempKeyOperations.set, {\n          [pathToString([...patch.path, {_key: sourceKey}])]: {\n            ...finalContentForThisPosition,\n            _key: temporaryKey,\n          },\n        })\n      }\n\n      // Phase 2: Update _key properties to restore the intended final keys\n      const finalKeyOperations: SanityPatchOperations = {}\n      finalKeyOperations.set = {}\n\n      for (const {sourceKey, targetKey} of patch.reorders) {\n        const temporaryKey = `__temp_reorder_${sourceKey}__`\n\n        Object.assign(finalKeyOperations.set, {\n          [pathToString([...patch.path, {_key: temporaryKey}, '_key'])]: targetKey,\n        })\n      }\n\n      return [tempKeyOperations, finalKeyOperations, ...serializePatches(rest)]\n    }\n    default: {\n      return []\n    }\n  }\n}\n\nfunction isUniquelyKeyed(arr: unknown[]): arr is KeyedSanityObject[] {\n  const seenKeys = new Set<string>()\n\n  for (const item of arr) {\n    // Each item must be a keyed object with a _key property\n    if (!isKeyedObject(item)) return false\n\n    // Each _key must be unique within the array\n    if (seenKeys.has(item._key)) return false\n\n    seenKeys.add(item._key)\n  }\n\n  return true\n}\n\n// Cache to avoid recomputing key-to-index mappings for the same array\nconst keyToIndexCache = new WeakMap<KeyedSanityObject[], Record<string, number>>()\n\nfunction getIndexForKey(keyedArray: KeyedSanityObject[], targetKey: string) {\n  const cachedMapping = keyToIndexCache.get(keyedArray)\n  if (cachedMapping) return cachedMapping[targetKey]\n\n  // Build a mapping from _key to array index\n  const keyToIndexMapping = keyedArray.reduce<Record<string, number>>(\n    (mapping, {_key}, arrayIndex) => {\n      mapping[_key] = arrayIndex\n      return mapping\n    },\n    {},\n  )\n\n  keyToIndexCache.set(keyedArray, keyToIndexMapping)\n\n  return keyToIndexMapping[targetKey]\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && !!value && !Array.isArray(value)\n}\n\n/**\n * Simplify returns `null` if the value given was `undefined`. This behavior\n * is the same as how `JSON.stringify` works so this is relatively expected\n * behavior.\n */\nfunction nullifyUndefined(item: unknown) {\n  if (item === undefined) return null\n  return item\n}\n\nfunction yes() {\n  return true\n}\n"],"mappings":"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"}

package/package.json

@@ -1,90 +1,73 @@
 {
   "name": "@sanity/diff-patch",
-  "version": "5.0.0",
+  "version": "7.0.0",
   "description": "Generates a set of Sanity patches needed to change an item (usually a document) from one shape to another",
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "source": "./src/index.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "engines": {
-    "node": ">=18.2"
-  },
-  "browserslist": "extends @sanity/browserslist-config",
-  "author": "Sanity.io <hello@sanity.io>",
+  "keywords": [
+    "compare",
+    "diff",
+    "mutation",
+    "patch",
+    "sanity"
+  ],
   "license": "MIT",
+  "author": "Sanity.io <hello@sanity.io>",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/sanity-io/diff-patch.git"
+  },
   "files": [
     "dist",
-    "!dist/stats.html",
+    "!dist/analyze-data.md",
     "src"
   ],
-  "keywords": [
-    "sanity",
-    "patch",
-    "diff",
-    "mutation",
-    "compare"
-  ],
-  "scripts": {
-    "clean": "rimraf dist coverage",
-    "coverage": "vitest --coverage",
-    "build": "pkg-utils build && pkg-utils --strict",
-    "prebuild": "npm run clean",
-    "lint": "eslint . && tsc --noEmit",
-    "test": "vitest --reporter=verbose",
-    "posttest": "npm run lint",
-    "prepublishOnly": "npm run build"
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "provenance": true
   },
   "dependencies": {
-    "@sanity/diff-match-patch": "^3.2.0"
+    "@sanity/diff-match-patch": "^3.2.1"
   },
   "devDependencies": {
-    "@sanity/client": "^6.27.2",
-    "@sanity/pkg-utils": "^6.13.4",
-    "@sanity/semantic-release-preset": "^5.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "@typescript-eslint/parser": "^5.62.0",
-    "@vitest/coverage-v8": "2.1.3",
-    "eslint": "^8.57.1",
-    "eslint-config-prettier": "^8.10.0",
-    "eslint-config-sanity": "^6.0.0",
-    "p-queue": "^8.1.0",
-    "prettier": "^3.4.2",
-    "rimraf": "^6.0.1",
-    "rollup-plugin-visualizer": "^5.14.0",
-    "semantic-release": "^24.2.1",
-    "typescript": "^5.7.3",
-    "vite": "^5.4.14",
-    "vitest": "^2.1.9"
-  },
-  "prettier": {
-    "semi": false,
-    "printWidth": 100,
-    "bracketSpacing": false,
-    "singleQuote": true
+    "@changesets/changelog-github": "^1.0.1",
+    "@changesets/cli": "^3.0.3",
+    "@rexxars/bundle-stats": "^2.0.0",
+    "@sanity/client": "^8.6.2",
+    "@sanity/pkg-utils": "^13.0.2",
+    "@types/node": "^22.20.4",
+    "@vitest/coverage-v8": "^5.0.1",
+    "knip": "^6.37.0",
+    "oxfmt": "^0.70.0",
+    "oxlint": "^1.85.0",
+    "p-queue": "^9.3.3",
+    "rimraf": "^6.1.3",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.0",
+    "vitest": "^5.0.1"
   },
-  "eslintConfig": {
-    "parserOptions": {
-      "ecmaVersion": 9,
-      "sourceType": "module",
-      "ecmaFeatures": {
-        "modules": true
-      }
-    },
-    "extends": [
-      "sanity",
-      "sanity/typescript",
-      "prettier"
-    ]
+  "browserslist": "extends @sanity/browserslist-config",
+  "engines": {
+    "node": ">=22.12.0"
   },
-  "packageManager": "pnpm@9.12.1"
-}
+  "scripts": {
+    "check": "knip",
+    "clean": "rimraf dist coverage",
+    "coverage": "vitest run --coverage",
+    "build": "pkg-utils build && pkg-utils check --strict",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "lint": "oxlint --deny-warnings . && tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "changeset": "changeset",
+    "version-packages": "changeset version && pnpm install --lockfile-only && oxfmt --write package.json",
+    "release": "changeset publish"
+  }
+}