index.d.ts

export interface ILCSResult {
  buffer1index: number;
  buffer2index: number;
  chain: null | ILCSResult;
}

/**
 * Expects two arrays, finds longest common sequence
 * @param {T[]} buffer1
 * @param {T[]} buffer2
 * @returns {ILCSResult}
 * @constructor
 */
export function LCS<T>(buffer1: T[], buffer2: T[]): ILCSResult;

export interface ICommResult<T> {
  buffer1: T[];
  buffer2: T[];
}

/**
 * We apply the LCS to build a 'comm'-style picture of the
 * differences between buffer1 and buffer2.
 * @param {T[]} buffer1
 * @param {T[]} buffer2
 * @returns {Array<ICommResult<T>>}
 */
export function diffComm<T>(buffer1: T[], buffer2: T[]): ICommResult<T>[];

export interface IDiffIndicesResult<T> {
  buffer1: [number, number];
  buffer1Content: T[];
  buffer2: [number, number];
  buffer2Content: T[];
}

/**
 * We apply the LCS to give a simple representation of the
 * offsets and lengths of mismatched chunks in the input
 * buffers. This is used by diff3MergeRegions.
 * @param {T[]} buffer1
 * @param {T[]} buffer2
 * @returns {IDiffIndicesResult<T>[]}
 */
export function diffIndices<T>(
  buffer1: T[],
  buffer2: T[]
): IDiffIndicesResult<T>[];

export interface IChunk<T> {
  offset: number;
  length: number;
  chunk: T[];
}

export interface IPatchRes<T> {
  buffer1: IChunk<T>;
  buffer2: IChunk<T>;
}

/**
 * We apply the LCS to build a JSON representation of a
 * diff(1)-style patch.
 * @param {T[]} buffer1
 * @param {T[]} buffer2
 * @returns {IPatchRes<T>[]}
 */
export function diffPatch<T>(buffer1: T[], buffer2: T[]): IPatchRes<T>[];

export function patch<T>(buffer: T[], patch: IPatchRes<T>[]): T[];

export interface IStableRegion<T> {
  stable: true;
  buffer: 'a' | 'o' | 'b';
  bufferStart: number;
  bufferLength: number;
  bufferContent: T[];
}

export interface IUnstableRegion<T> {
  stable: false;
  aStart: number;
  aLength: number;
  aContent: T[];
  bStart: number;
  bLength: number;
  bContent: T[];
  oStart: number;
  oLength: number;
  oContent: T[];
}

export type IRegion<T> = IStableRegion<T> | IUnstableRegion<T>;

/**
 * Given three buffers, A, O, and B, where both A and B are
 * independently derived from O, returns a fairly complicated
 * internal representation of merge decisions it's taken. The
 * interested reader may wish to consult
 *
 * Sanjeev Khanna, Keshav Kunal, and Benjamin C. Pierce.
 * 'A Formal Investigation of ' In Arvind and Prasad,
 * editors, Foundations of Software Technology and Theoretical
 * Computer Science (FSTTCS), December 2007.
 *
 * (http://www.cis.upenn.edu/~bcpierce/papers/diff3-short.pdf)
 *
 * @param {T[]} a
 * @param {T[]} o
 * @param {T[]} b
 * @returns {IRegion<T>[]}
 */
export function diff3MergeRegions<T>(a: T[], o: T[], b: T[]): IRegion<T>[];

export interface MergeRegion<T> {
  ok?: T[];
  conflict?: {
    a: T[];
    aIndex: number;
    b: T[];
    bIndex: number;
    o: T[];
    oIndex: number;
  };
}

export interface MergeResult {
  conflict: boolean;
  result: string[];
}

export interface IMergeOptions {
  excludeFalseConflicts?: boolean;
  stringSeparator?: string | RegExp;
}

/**
 * Applies the output of diff3MergeRegions to actually
 * construct the merged buffer; the returned result alternates
 * between 'ok' and 'conflict' blocks.
 * A "false conflict" is where `a` and `b` both change the same from `o`
 *
 * @param {string | T[]} a
 * @param {string | T[]} o
 * @param {string | T[]} b
 * @param {{excludeFalseConflicts: boolean; stringSeparator: RegExp}} options
 * @returns {MergeRegion<T>[]}
 */
export function diff3Merge<T>(
  a: string | T[],
  o: string | T[],
  b: string | T[],
  options?: IMergeOptions
): MergeRegion<T>[];

export function merge<T>(
  a: string | T[],
  o: string | T[],
  b: string | T[],
  options?: IMergeOptions
): MergeResult;

export function mergeDiff3<T>(
  a: string | T[],
  o: string | T[],
  b: string | T[],
  options?: IMergeOptions & {
    label?: {
      a?: string;
      o?: string;
      b?: string;
    }
  }
): MergeResult;

export function mergeDigIn<T>(
  a: string | T[],
  o: string | T[],
  b: string | T[],
  options?: IMergeOptions
): MergeResult;