@sanity/diff-patch 5.0.0 → 7.0.0

package/dist/index.d.ts

@@ -1,156 +1,119 @@
 /**
- * Represents an error that occurred during a diff process.
- * Contains `path`, `value` and `serializedPath` properties,
- * which is helpful for debugging and showing friendly messages.
+ * A segment of a path
  *
  * @public
  */
-export declare class DiffError extends Error {
-  path: Path
-  value: unknown
-  serializedPath: string
-  constructor(message: string, path: Path, value?: unknown)
-}
-
+type PathSegment = string | number | {
+  _key: string;
+} | [number | '', number | ''];
 /**
- * Diffs two items and returns an array of patches.
- * Note that this is different from `diffPatch`, which generates _mutations_.
+ * An array of path segments representing a path in a document
  *
- * @param itemA - The first item to compare
- * @param itemB - The second item to compare
- * @param opts - Options for the diff generation
- * @param path - Path to the current item
- * @param patches - Array of patches to append the results to. Note that this is MUTATED.
- * @returns Array of patches
  * @public
  */
-export declare function diffItem(
-  itemA: unknown,
-  itemB: unknown,
-  opts?: DiffOptions,
-  path?: Path,
-  patches?: Patch[],
-): Patch[]
-
+type Path = PathSegment[];
 /**
- * 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
+ * A Sanity `set` patch mutation operation
+ * Replaces the current path, does not merge
  *
  * @public
  */
-export declare interface DiffMatchPatch {
-  op: 'diffMatchPatch'
-  path: Path
-  value: string
+interface SanitySetPatchOperation {
+  set: Record<string, unknown>;
 }
-
 /**
- * Options for the diff-match-patch algorithm.
+ * A Sanity `unset` patch mutation operation
+ * Unsets the entire value of the given path
  *
  * @public
  */
-export declare interface DiffMatchPatchOptions {
-  /**
-   * Whether or not to use diff-match-patch at all
-   *
-   * @defaultValue `true`
-   */
-  enabled: boolean
-  /**
-   * Threshold at which to start using diff-match-patch instead of a regular `set` patch.
-   *
-   * @defaultValue `30`
-   */
-  lengthThresholdAbsolute: number
-  /**
-   * Only use generated diff-match-patch if the patch length is less than or equal to
-   * (targetString * relative). Example: A 100 character target with a relative factor
-   * of 1.2 will allow a 120 character diff-match-patch. If larger than this number,
-   * it will fall back to a regular `set` patch.
-   *
-   * @defaultValue `1.2`
-   */
-  lengthThresholdRelative: number
+interface SanityUnsetPatchOperation {
+  unset: string[];
 }
-
 /**
- * Options for diff generation, where all DMP properties are required
+ * A Sanity `insert` patch mutation operation
+ * Inserts the given items at the given path (before/after)
  *
  * @public
  */
-export declare type DiffOptions = PatchOptions & {
-  diffMatchPatch: Required<DiffMatchPatchOptions>
+interface SanityInsertPatchOperation {
+  insert: {
+    before: string;
+    items: unknown[];
+  } | {
+    after: string;
+    items: unknown[];
+  } | {
+    replace: string;
+    items: unknown[];
+  };
 }
-
 /**
- * Generates an array of mutations for Sanity, based on the differences between
- * the two passed documents/trees.
+ * A Sanity `diffMatchPatch` patch mutation operation
+ * Patches the given path with the given unidiff string.
  *
- * @param itemA - The first document/tree to compare
- * @param itemB - The second document/tree to compare
- * @param opts - Options for the diff generation
- * @returns Array of mutations
  * @public
  */
-export declare function diffPatch(
-  itemA: DocumentStub,
-  itemB: DocumentStub,
-  opts?: PatchOptions,
-): SanityPatchMutation[]
-
+interface SanityDiffMatchPatchOperation {
+  diffMatchPatch: Record<string, string>;
+}
 /**
- * Represents a partial Sanity document (eg a "stub").
+ * Serializable patch operations that can be applied to a Sanity document.
  *
  * @public
  */
-export declare interface DocumentStub {
-  _id?: string
-  _type?: string
-  _rev?: string
-  _createdAt?: string
-  _updatedAt?: string
-  [key: string]: unknown
+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
+ */
+interface SanityPatch extends SanityPatchOperations {
+  id: string;
+  ifRevisionID?: string;
 }
-
 /**
- * A `insert` operation
- * Inserts the given items _after_ the given path
- * Note: NOT a serializable mutation, see {@link SanityInsertPatch} for that
+ * A mutation containing a single patch
  *
  * @public
  */
-export declare interface InsertAfterPatch {
-  op: 'insert'
-  after: Path
-  items: any[]
+interface SanityPatchMutation {
+  patch: SanityPatch;
 }
-
 /**
- * A patch containing either a Sanity set, unset, insert or diffMatchPatch operation
+ * Represents a partial Sanity document (eg a "stub").
  *
  * @public
  */
-export declare type Patch = SetPatch | UnsetPatch | InsertAfterPatch | DiffMatchPatch
-
+interface DocumentStub {
+  _id?: string;
+  _type?: string;
+  _rev?: string;
+  _createdAt?: string;
+  _updatedAt?: string;
+  [key: string]: unknown;
+}
 /**
  * Options for the patch generator
  *
  * @public
  */
-export declare interface PatchOptions {
+interface PatchOptions {
   /**
    * Document ID to apply the patch to.
    *
    * @defaultValue `undefined` - tries to extract `_id` from passed document
    */
-  id?: string
+  id?: string;
   /**
    * Base path to apply the patch to - useful if diffing sub-branches of a document.
    *
    * @defaultValue `[]` - eg root of the document
    */
-  basePath?: Path
+  basePath?: Path;
   /**
    * Only apply the patch if the document revision matches this value.
    * If the property is the boolean value `true`, it will attempt to extract
@@ -158,142 +121,42 @@ export declare interface PatchOptions {
    *
    * @defaultValue `undefined` (do not apply revision check)
    */
-  ifRevisionID?: string | true
-  /**
-   * Whether or not to hide warnings during the diff process.
-   *
-   * @defaultValue `false`
-   */
-  hideWarnings?: boolean
-  /**
-   * Options for the diff-match-patch algorithm.
-   */
-  diffMatchPatch?: Partial<DiffMatchPatchOptions>
-}
-
-/**
- * An array of path segments representing a path in a document
- *
- * @public
- */
-export declare type Path = PathSegment[]
-
-/**
- * A segment of a path
- *
- * @public
- */
-export declare type PathSegment =
-  | string
-  | number
-  | {
-      _key: string
-    }
-  | [number | '', number | '']
-
-/**
- * A Sanity `diffMatchPatch` patch mutation operation
- * Patches the given path with the given unidiff string.
- *
- * @public
- */
-export declare interface SanityDiffMatchPatch {
-  id: string
-  diffMatchPatch: {
-    [key: string]: string
-  }
-}
-
-/**
- * A Sanity `insert` patch mutation operation
- * Inserts the given items at the given path (before/after)
- *
- * @public
- */
-export declare interface SanityInsertPatch {
-  id: string
-  insert:
-    | {
-        before: string
-        items: any[]
-      }
-    | {
-        after: string
-        items: any[]
-      }
-    | {
-        replace: string
-        items: any[]
-      }
-}
-
-/**
- * A patch containing either a set, unset, insert or diffMatchPatch operation
- *
- * @public
- */
-export declare type SanityPatch =
-  | SanitySetPatch
-  | SanityUnsetPatch
-  | SanityInsertPatch
-  | SanityDiffMatchPatch
-
-/**
- * A mutation containing a single patch
- *
- * @public
- */
-export declare interface SanityPatchMutation {
-  patch: SanityPatch
+  ifRevisionID?: string | true;
 }
-
 /**
- * A Sanity `set` patch mutation operation
- * Replaces the current path, does not merge
- *
- * @public
- */
-export declare interface SanitySetPatch {
-  id: string
-  set: {
-    [key: string]: any
-  }
-}
-
-/**
- * A Sanity `unset` patch mutation operation
- * Unsets the entire value of the given path
+ * Generates an array of mutations for Sanity, based on the differences between
+ * the two passed documents/trees.
  *
+ * @param source - The first document/tree to compare
+ * @param target - The second document/tree to compare
+ * @param opts - Options for the diff generation
+ * @returns Array of mutations
  * @public
  */
-export declare interface SanityUnsetPatch {
-  id: string
-  unset: string[]
-}
-
+export declare function diffPatch(source: DocumentStub, target: DocumentStub, options?: PatchOptions): SanityPatchMutation[];
 /**
- * A `set` operation
- * Replaces the current path, does not merge
- * Note: NOT a serializable mutation, see {@link SanitySetPatch} for that
+ * Generates an array of patch operation objects for Sanity, based on the
+ * differences between the two passed values
  *
+ * @param source - The source value to start off with
+ * @param target - The target value that the patch operations will aim to create
+ * @param basePath - An optional path that will be prefixed to all subsequent patch operations
+ * @returns Array of mutations
  * @public
  */
-export declare interface SetPatch {
-  op: 'set'
-  path: Path
-  value: unknown
-}
-
+export declare function diffValue(source: unknown, target: unknown, basePath?: Path): SanityPatchOperations[];
 /**
- * A `unset` operation
- * Unsets the entire value of the given path
- * Note: NOT a serializable mutation, see {@link SanityUnsetPatch} for that
+ * Represents an error that occurred during a diff process.
+ * Contains `path`, `value` and `serializedPath` properties,
+ * which is helpful for debugging and showing friendly messages.
  *
  * @public
  */
-export declare interface UnsetPatch {
-  op: 'unset'
-  path: Path
+export declare class DiffError extends Error {
+  path: Path;
+  value: unknown;
+  serializedPath: string;
+  constructor(message: string, path: Path, value?: unknown);
 }
-
-export {}
+export type { DocumentStub, PatchOptions, Path, PathSegment, SanityPatch, SanityPatchMutation, SanityPatchOperations };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/paths.ts","../src/patches.ts","../src/diffPatch.ts","../src/diffError.ts"],"mappings":"AAOA;;;;;KAAY;EAGP;;;;;;;KAQO,OAAO;;;;;;;UC2DF;EACf,KAAK;;;;;;;;UASU;EACf;;;;;;;;UASe;EACf;IACK;IAAgB;;IAChB;IAAe;;IACf;IAAiB;;;;;;;;;UASP;EACf,gBAAgB;;;;;;;KAQN,wBAAwB,QAClC,0BACE,4BACA,6BACA;;;;;;;;;UAWa,oBAAoB;EACnC;EACA;;;;;;;UAQe;EACf,OAAO;;;;;;;UClGQ;EACf;EACA;EACA;EACA;EACA;GACC;;;;;;;UAQc;;;;;;EAMf;;;;;;EAOA,WAAW;;;;;;;;EASX;;;;;;;;;;;;wBAac,UACd,QAAQ,cACR,QAAQ,cACR,UAAS,eACR;;;;;;;;;;;wBA0Ca,UACd,iBACA,iBACA,WAAU,OACT;;;;;;;;qBCzIU,kBAAkB;EACtB,MAAM;EACN;EACA;EAEP,YAAY,iBAAiB,MAAM,MAAM"}