@twick/2d 0.14.21 → 0.15.0

package/src/lib/code/diff.test.ts

@@ -1,311 +0,0 @@
-import {expect, test} from 'vitest';
-import {patienceDiff} from './diff';
-
-test('should find simple strings', () => {
-  const result = patienceDiff(
-    ['abc', 'def', 'ghi'],
-    ['abc', 'def', 'ghi', 'jkl'],
-  );
-
-  // printDiff(result);
-  /*
-      abc
-      def
-      ghi
-    + jkl
-  */
-
-  expect(result).toMatchObject({
-    lines: [
-      // We don't care too much about the first three line results
-      {},
-      {},
-      {},
-      {
-        line: 'jkl',
-        // We care that we know that this line was not there.
-        aIndex: -1,
-        bIndex: 3,
-      },
-    ],
-  });
-});
-
-test('should diff code effectively', () => {
-  const result = patienceDiff(
-    `function test() {
-  console.log('hello world');
-}`.split('\n'),
-    `function test() {
-  console.log('hello world');
-}
-
-function other() {
-  return 5;
-}`.split('\n'),
-  );
-
-  // printDiff(result);
-  /*
-      function test() {
-        console.log('hello world');
-      }
-    + 
-    + function other() {
-    +   return 5;
-    + }
-  */
-
-  expect(result).toMatchObject({
-    lines: [
-      {
-        line: 'function test() {',
-      },
-      {
-        line: "  console.log('hello world');",
-      },
-      {
-        line: '}',
-      },
-      {
-        line: '',
-      },
-      {
-        line: 'function other() {',
-        // Make sure this line was added
-        aIndex: -1,
-      },
-      {
-        line: '  return 5;',
-        aIndex: -1,
-      },
-      {
-        line: '}',
-        aIndex: -1,
-      },
-    ],
-  });
-});
-
-test('should diff code movement effectively', () => {
-  const result = patienceDiff(
-    `function test() {
-  console.log('hello world');
-}
-
-function other() {
-  return 5;
-}`.split('\n'),
-    `function other() {
-  return 5;
-}
-
-function test() {
-  console.log('hello world');
-}`.split('\n'),
-  );
-
-  // printDiff(result);
-  /*
-    - function test() {
-    -   console.log('hello world');
-    - }
-    - 
-      function other() {
-        return 5;
-      }
-    + 
-    + function test() {
-    +   console.log('hello world');
-    + }
-  */
-
-  expect(result).toMatchObject({
-    lines: [
-      {
-        line: 'function test() {',
-        // Make sure this line was removed
-        bIndex: -1,
-      },
-      {
-        line: "  console.log('hello world');",
-        bIndex: -1,
-      },
-      {
-        line: '}',
-        bIndex: -1,
-      },
-      {
-        line: '',
-        bIndex: -1,
-      },
-      {
-        line: 'function other() {',
-      },
-      {
-        line: '  return 5;',
-      },
-      {
-        line: '}',
-      },
-      {
-        line: '',
-        aIndex: -1,
-      },
-      {
-        line: 'function test() {',
-        // Make sure this line was added
-        aIndex: -1,
-      },
-      {
-        line: "  console.log('hello world');",
-        aIndex: -1,
-      },
-      {
-        line: '}',
-        aIndex: -1,
-      },
-    ],
-  });
-});
-
-test('should diff complex code movement effectively', () => {
-  const result = patienceDiff(
-    `void Chunk_copy(Chunk *src, size_t src_start, Chunk *dst, size_t dst_start, size_t n)
-{
-    if (!Chunk_bounds_check(src, src_start, n)) return;
-    if (!Chunk_bounds_check(dst, dst_start, n)) return;
-
-    memcpy(dst->data + dst_start, src->data + src_start, n);
-}
-
-int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)
-{
-    if (chunk == NULL) return 0;
-
-    return start <= chunk->length && n <= chunk->length - start;
-}`.split('\n'),
-    `int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)
-{
-    if (chunk == NULL) return 0;
-
-    return start <= chunk->length && n <= chunk->length - start;
-}
-
-void Chunk_copy(Chunk *src, size_t src_start, Chunk *dst, size_t dst_start, size_t n)
-{
-    if (!Chunk_bounds_check(src, src_start, n)) return;
-    if (!Chunk_bounds_check(dst, dst_start, n)) return;
-
-    memcpy(dst->data + dst_start, src->data + src_start, n);
-}`.split('\n'),
-  );
-
-  // printDiff(result);
-  /* 
-    + int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)
-    + {
-    +     if (chunk == NULL) return 0;
-    + 
-    +     return start <= chunk->length && n <= chunk->length - start;
-    + }
-    + 
-      void Chunk_copy(Chunk *src, size_t src_start, Chunk *dst, size_t dst_start, size_t n)
-      {
-          if (!Chunk_bounds_check(src, src_start, n)) return;
-          if (!Chunk_bounds_check(dst, dst_start, n)) return;
-      
-          memcpy(dst->data + dst_start, src->data + src_start, n);
-      }
-    -
-    - int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)
-    - {
-    -     if (chunk == NULL) return 0;
-    -
-    -     return start <= chunk->length && n <= chunk->length - start;
-    - }
-  */
-
-  expect(result).toMatchObject({
-    lines: [
-      {
-        line: 'int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)',
-        // Make sure this is the line added
-        aIndex: -1,
-      },
-      {
-        line: '{',
-        aIndex: -1,
-      },
-      {
-        line: '    if (chunk == NULL) return 0;',
-        aIndex: -1,
-      },
-      {
-        line: '',
-        aIndex: -1,
-      },
-      {
-        line: '    return start <= chunk->length && n <= chunk->length - start;',
-        aIndex: -1,
-      },
-      {
-        line: '}',
-        aIndex: -1,
-      },
-      {
-        line: '',
-      },
-      {
-        line: 'void Chunk_copy(Chunk *src, size_t src_start, Chunk *dst, size_t dst_start, size_t n)',
-      },
-      {
-        line: '{',
-      },
-      {
-        line: '    if (!Chunk_bounds_check(src, src_start, n)) return;',
-      },
-      {
-        line: '    if (!Chunk_bounds_check(dst, dst_start, n)) return;',
-      },
-      {
-        line: '',
-      },
-      {
-        line: '    memcpy(dst->data + dst_start, src->data + src_start, n);',
-      },
-      {
-        line: '}',
-      },
-      {
-        line: '',
-        bIndex: -1,
-      },
-      {
-        line: 'int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)',
-        // Make sure this is the line removed
-        bIndex: -1,
-      },
-      {
-        line: '{',
-        bIndex: -1,
-      },
-      {
-        line: '    if (chunk == NULL) return 0;',
-        bIndex: -1,
-      },
-      {
-        line: '',
-        bIndex: -1,
-      },
-      {
-        line: '    return start <= chunk->length && n <= chunk->length - start;',
-        bIndex: -1,
-      },
-      {
-        line: '}',
-        bIndex: -1,
-      },
-    ],
-  });
-});

package/src/lib/code/diff.ts

@@ -1,319 +0,0 @@
-type Subsequence = {
-  aIndex: number;
-  bIndex: number;
-  prev?: Subsequence | undefined;
-};
-
-/**
- * Performs a patience diff on two arrays of strings, returning an object
- * containing the lines that were deleted, inserted, and potentially moved
- * lines. The plus parameter can result in a significant performance hit due
- * to additional Longest Common Substring searches.
- *
- * @param aLines - The original array of strings
- * @param bLines - The new array of strings
- * @param plus - Whether to return the moved lines
- *
- * Adapted from Jonathan "jonTrent" Trent's patience-diff algorithm.
- * Types and tests added by Hunter "hhenrichsen" Henrichsen.
- *
- * {@link https://github.com/jonTrent/PatienceDiff}
- */
-export function patienceDiff(
-  aLines: string[],
-  bLines: string[],
-): {
-  lines: {
-    line: string;
-    aIndex: number;
-    bIndex: number;
-  }[];
-  lineCountDeleted: number;
-  lineCountInserted: number;
-} {
-  /**
-   * Finds all unique values in lines[start...end], inclusive. This
-   * function is used in preparation for determining the longest common
-   * subsequence.
-   *
-   * @param lines - The array to search
-   * @param start - The starting index (inclusive)
-   * @param end - The ending index (inclusive)
-   * @returns A map of the unique lines to their index
-   */
-  function findUnique(lines: string[], start: number, end: number) {
-    const lineMap = new Map<string, {count: number; index: number}>();
-    for (let i = start; i <= end; i++) {
-      const line = lines[i];
-      const data = lineMap.get(line);
-      if (data) {
-        data.count++;
-        data.index = i;
-      } else {
-        lineMap.set(line, {count: 1, index: i});
-      }
-    }
-
-    const newMap = new Map<string, number>();
-    for (const [key, value] of lineMap) {
-      if (value.count === 1) {
-        newMap.set(key, value.index);
-      }
-    }
-
-    return newMap;
-  }
-
-  /**
-   * Finds all the unique common entries between aArray[aStart...aEnd] and
-   * bArray[bStart...bEnd], inclusive. This function uses findUnique to pare
-   * down the aArray and bArray ranges first, before then walking the
-   * comparison between the two arrays.
-   *
-   *
-   * @param aArray - The original array
-   * @param aStart - The start of the original array to search
-   * @param aEnd - The end of the original array to search, inclusive
-   * @param bArray - The new array
-   * @param bStart - the start of the new array to search
-   * @param bEnd - The end of the new array to search, inclusive
-   * @returns a Map, with the key as the common line between aArray and
-   * bArray, with the value as an object containing the array indices of the
-   * matching uniqe lines.
-   */
-  function uniqueCommon(
-    aArray: string[],
-    aStart: number,
-    aEnd: number,
-    bArray: string[],
-    bStart: number,
-    bEnd: number,
-  ): Map<string, Subsequence> {
-    const aUnique = findUnique(aArray, aStart, aEnd);
-    const bUnique = findUnique(bArray, bStart, bEnd);
-
-    return [...aUnique.entries()].reduce<Map<string, Subsequence>>(
-      (paired, [key, value]) => {
-        const bIndex = bUnique.get(key);
-        if (bIndex !== undefined) {
-          paired.set(key, {
-            aIndex: value,
-            bIndex,
-          });
-        }
-        return paired;
-      },
-      new Map(),
-    );
-  }
-
-  /**
-   * Takes a map from the unique common lines between two arrays and determines
-   * the longest common subsequence.
-   *
-   * @see uniqueCommon
-   *
-   * @param abMap - The map of unique common lines between two arrays.
-   * @returns An array of objects containing the indices of the longest common
-   * subsequence.
-   */
-  function longestCommonSubsequence(
-    abMap: Map<string, Subsequence>,
-  ): Subsequence[] {
-    const jagged: [Subsequence][] = [];
-
-    abMap.forEach(value => {
-      let i = 0;
-      while (jagged[i] && jagged[i].at(-1)!.bIndex < value.bIndex) {
-        i++;
-      }
-
-      if (i > 0) {
-        value.prev = jagged[i - 1].at(-1);
-      }
-
-      if (!jagged[i]) {
-        jagged[i] = [value];
-      } else {
-        jagged[i].push(value);
-      }
-    });
-
-    // Pull out the longest common subsequence
-    let lcs: Subsequence[] = [];
-
-    if (jagged.length > 0) {
-      lcs = [jagged.at(-1)!.at(-1)!];
-      let cursor = lcs.at(-1);
-      while (cursor?.prev) {
-        cursor = cursor.prev;
-        lcs.push(cursor);
-      }
-    }
-
-    return lcs.reverse();
-  }
-
-  /**
-   * Keeps track of the aLines that have been deleted, are shared between aLines
-   * and bLines, and bLines that have been inserted.
-   */
-  const result: {
-    line: string;
-    aIndex: number;
-    bIndex: number;
-    moved: boolean;
-  }[] = [];
-  let deleted = 0;
-  let inserted = 0;
-
-  function addToResult(aIndex: number, bIndex: number) {
-    if (bIndex < 0) {
-      deleted++;
-    } else if (aIndex < 0) {
-      inserted++;
-    }
-    result.push({
-      line: 0 <= aIndex ? aLines[aIndex] : bLines[bIndex],
-      aIndex,
-      bIndex,
-      moved: false,
-    });
-  }
-
-  function addSubMatch(
-    aStart: number,
-    aEnd: number,
-    bStart: number,
-    bEnd: number,
-  ) {
-    // Match any lines at the beginning of aLines and bLines.
-    while (
-      aStart <= aEnd &&
-      bStart <= bEnd &&
-      aLines[aStart] === bLines[bStart]
-    ) {
-      addToResult(aStart++, bStart++);
-    }
-
-    // Match any lines at the end of aLines and bLines, but don't place them
-    // in the "result" array just yet, as the lines between these matches at
-    // the beginning and the end need to be analyzed first.
-    const aEndTemp = aEnd;
-    while (aStart <= aEnd && bStart <= bEnd && aLines[aEnd] === bLines[bEnd]) {
-      aEnd--;
-      bEnd--;
-    }
-
-    // Now, check to determine with the remaining lines in the subsequence
-    // whether there are any unique common lines between aLines and bLines.
-    //
-    // If not, add the subsequence to the result (all aLines having been
-    // deleted, and all bLines having been inserted).
-    //
-    // If there are unique common lines between aLines and bLines, then let's
-    // recursively perform the patience diff on the subsequence.
-    const uniqueCommonMap = uniqueCommon(
-      aLines,
-      aStart,
-      aEnd,
-      bLines,
-      bStart,
-      bEnd,
-    );
-
-    if (uniqueCommonMap.size === 0) {
-      while (aStart <= aEnd) {
-        addToResult(aStart++, -1);
-      }
-      while (bStart <= bEnd) {
-        addToResult(-1, bStart++);
-      }
-    } else {
-      recurseLCS(aStart, aEnd, bStart, bEnd, uniqueCommonMap);
-    }
-
-    // Finally, let's add the matches at the end to the result.
-    while (aEnd < aEndTemp) {
-      addToResult(++aEnd, ++bEnd);
-    }
-  }
-
-  /**
-   * Finds the longest common subsequence between the arrays
-   * aLines[aStart...aEnd] and bLines[bStart...bEnd], inclusive. Then for each
-   * subsequence, recursively performs another LCS search (via addSubMatch),
-   * until there are none found, at which point the subsequence is dumped to
-   * the result.
-   *
-   * @param aStart - The start of the original array to search
-   * @param aEnd - The end of the original array to search, inclusive
-   * @param bStart - The start of the new array to search
-   * @param bEnd - The end of the new array to search, inclusive
-   * @param uniqueCommonMap - A map of the unique common lines between
-   * aLines[aStart...aEnd] and bLines[bStart...bEnd], inclusive.
-   */
-  function recurseLCS(
-    aStart: number,
-    aEnd: number,
-    bStart: number,
-    bEnd: number,
-    uniqueCommonMap: Map<string, Subsequence> = uniqueCommon(
-      aLines,
-      aStart,
-      aEnd,
-      bLines,
-      bStart,
-      bEnd,
-    ),
-  ) {
-    const lcs = longestCommonSubsequence(uniqueCommonMap);
-
-    if (lcs.length === 0) {
-      addSubMatch(aStart, aEnd, bStart, bEnd);
-    } else {
-      if (aStart < lcs[0].aIndex || bStart < lcs[0].bIndex) {
-        addSubMatch(aStart, lcs[0].aIndex - 1, bStart, lcs[0].bIndex - 1);
-      }
-
-      let i;
-      for (i = 0; i < lcs.length - 1; i++) {
-        addSubMatch(
-          lcs[i].aIndex,
-          lcs[i + 1].aIndex - 1,
-          lcs[i].bIndex,
-          lcs[i + 1].bIndex - 1,
-        );
-      }
-
-      if (lcs[i].aIndex <= aEnd || lcs[i].bIndex <= bEnd) {
-        addSubMatch(lcs[i].aIndex, aEnd, lcs[i].bIndex, bEnd);
-      }
-    }
-  }
-
-  recurseLCS(0, aLines.length - 1, 0, bLines.length - 1);
-
-  return {
-    lines: result,
-    lineCountDeleted: deleted,
-    lineCountInserted: inserted,
-  };
-}
-
-/**
- * Utility function for debugging patienceDiff.
- *
- * @internal
- */
-export function printDiff(diff: ReturnType<typeof patienceDiff>) {
-  diff.lines.forEach(line => {
-    if (line.bIndex < 0) {
-      console.log(`- ${line.line}`);
-    } else if (line.aIndex < 0) {
-      console.log(`+ ${line.line}`);
-    } else {
-      console.log(`  ${line.line}`);
-    }
-  });
-}