@sanity/diff-patch 5.0.0 → 6.0.0

package/src/index.ts

@@ -1,20 +1,8 @@
-export {diffPatch, diffItem} from './diffPatch.js'
+export {diffPatch, diffValue} from './diffPatch.js'
 export {DiffError} from './diffError.js'
 
-export type {
-  DiffMatchPatch,
-  InsertAfterPatch,
-  Patch,
-  SanityDiffMatchPatch,
-  SanityInsertPatch,
-  SanityPatch,
-  SanityPatchMutation,
-  SanitySetPatch,
-  SanityUnsetPatch,
-  SetPatch,
-  UnsetPatch,
-} from './patches.js'
+export type {SanityPatch, SanityPatchMutation, SanityPatchOperations} from './patches.js'
 
-export type {DiffMatchPatchOptions, DiffOptions, DocumentStub, PatchOptions} from './diffPatch.js'
+export type {DocumentStub, PatchOptions} from './diffPatch.js'
 
 export type {Path, PathSegment} from './paths.js'

package/src/patches.ts

@@ -1,11 +1,10 @@
-import type {Path} from './paths.js'
+import type {KeyedSanityObject, Path} from './paths.js'
 
 /**
  * A `set` operation
  * Replaces the current path, does not merge
- * Note: NOT a serializable mutation, see {@link SanitySetPatch} for that
  *
- * @public
+ * @internal
  */
 export interface SetPatch {
   op: 'set'
@@ -16,9 +15,8 @@ export interface SetPatch {
 /**
  * A `unset` operation
  * Unsets the entire value of the given path
- * Note: NOT a serializable mutation, see {@link SanityUnsetPatch} for that
  *
- * @public
+ * @internal
  */
 export interface UnsetPatch {
   op: 'unset'
@@ -28,22 +26,21 @@ export interface UnsetPatch {
 /**
  * A `insert` operation
  * Inserts the given items _after_ the given path
- * Note: NOT a serializable mutation, see {@link SanityInsertPatch} for that
  *
- * @public
+ * @internal
  */
-export interface InsertAfterPatch {
+export interface InsertPatch {
   op: 'insert'
-  after: Path
+  position: 'before' | 'after' | 'replace'
+  path: Path
   items: any[]
 }
 
 /**
  * A `diffMatchPatch` operation
  * Applies the given `value` (unidiff format) to the given path. Must be a string.
- * Note: NOT a serializable mutation, see {@link SanityDiffMatchPatch} for that
  *
- * @public
+ * @internal
  */
 export interface DiffMatchPatch {
   op: 'diffMatchPatch'
@@ -52,11 +49,25 @@ export interface DiffMatchPatch {
 }
 
 /**
- * A patch containing either a Sanity set, unset, insert or diffMatchPatch operation
+ * A `reorder` operation used to ...
+ *
+ * Note: NOT a serializable mutation.
  *
  * @public
  */
-export type Patch = SetPatch | UnsetPatch | InsertAfterPatch | DiffMatchPatch
+export interface ReorderPatch {
+  op: 'reorder'
+  path: Path
+  snapshot: KeyedSanityObject[]
+  reorders: {sourceKey: string; targetKey: string}[]
+}
+
+/**
+ * Internal patch representation used during diff generation
+ *
+ * @internal
+ */
+export type Patch = SetPatch | UnsetPatch | InsertPatch | DiffMatchPatch | ReorderPatch
 
 /**
  * A Sanity `set` patch mutation operation
@@ -64,9 +75,8 @@ export type Patch = SetPatch | UnsetPatch | InsertAfterPatch | DiffMatchPatch
  *
  * @public
  */
-export interface SanitySetPatch {
-  id: string
-  set: {[key: string]: any}
+export interface SanitySetPatchOperation {
+  set: Record<string, unknown>
 }
 
 /**
@@ -75,8 +85,7 @@ export interface SanitySetPatch {
  *
  * @public
  */
-export interface SanityUnsetPatch {
-  id: string
+export interface SanityUnsetPatchOperation {
   unset: string[]
 }
 
@@ -86,12 +95,11 @@ export interface SanityUnsetPatch {
  *
  * @public
  */
-export interface SanityInsertPatch {
-  id: string
+export interface SanityInsertPatchOperation {
   insert:
-    | {before: string; items: any[]}
-    | {after: string; items: any[]}
-    | {replace: string; items: any[]}
+    | {before: string; items: unknown[]}
+    | {after: string; items: unknown[]}
+    | {replace: string; items: unknown[]}
 }
 
 /**
@@ -100,21 +108,34 @@ export interface SanityInsertPatch {
  *
  * @public
  */
-export interface SanityDiffMatchPatch {
-  id: string
-  diffMatchPatch: {[key: string]: string}
+export interface SanityDiffMatchPatchOperation {
+  diffMatchPatch: Record<string, string>
 }
 
 /**
- * A patch containing either a set, unset, insert or diffMatchPatch operation
+ * Serializable patch operations that can be applied to a Sanity document.
+ *
+ * @public
+ */
+export type SanityPatchOperations = Partial<
+  SanitySetPatchOperation &
+    SanityUnsetPatchOperation &
+    SanityInsertPatchOperation &
+    SanityDiffMatchPatchOperation
+>
+
+/**
+ * Meant to be used as the body of a {@link SanityPatchMutation}'s `patch` key.
+ *
+ * Contains additional properties to target a particular ID and optionally add
+ * an optimistic lock via [`ifRevisionID`](https://www.sanity.io/docs/content-lake/transactions#k29b2c75639d5).
  *
  * @public
  */
-export type SanityPatch =
-  | SanitySetPatch
-  | SanityUnsetPatch
-  | SanityInsertPatch
-  | SanityDiffMatchPatch
+export interface SanityPatch extends SanityPatchOperations {
+  id: string
+  ifRevisionID?: string
+}
 
 /**
  * A mutation containing a single patch

package/src/paths.ts

@@ -1,5 +1,3 @@
-import type {KeyedSanityObject} from './diffPatch.js'
-
 const IS_DOTTABLE_RE = /^[A-Za-z_][A-Za-z0-9_]*$/
 
 /**
@@ -54,6 +52,16 @@ export function pathToString(path: Path): string {
   }, '')
 }
 
-function isKeyedObject(obj: any): obj is KeyedSanityObject {
-  return typeof obj === 'object' && typeof obj._key === 'string'
+/**
+ * An object (record) that has a `_key` property
+ *
+ * @internal
+ */
+export interface KeyedSanityObject {
+  [key: string]: unknown
+  _key: string
+}
+
+export function isKeyedObject(obj: unknown): obj is KeyedSanityObject {
+  return typeof obj === 'object' && !!obj && '_key' in obj && typeof obj._key === 'string'
 }

package/src/setOperations.ts

@@ -0,0 +1,29 @@
+/// <reference lib="esnext" />
+
+export function difference<T>(source: Set<T>, target: Set<T>): Set<T> {
+  if ('difference' in Set.prototype) {
+    return source.difference(target)
+  }
+
+  const result = new Set<T>()
+  for (const item of source) {
+    if (!target.has(item)) {
+      result.add(item)
+    }
+  }
+  return result
+}
+
+export function intersection<T>(source: Set<T>, target: Set<T>): Set<T> {
+  if ('intersection' in Set.prototype) {
+    return source.intersection(target)
+  }
+
+  const result = new Set<T>()
+  for (const item of source) {
+    if (target.has(item)) {
+      result.add(item)
+    }
+  }
+  return result
+}