@twick/2d 0.13.0 → 0.14.2

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

@@ -1,74 +1,74 @@
-import {describe, expect, test} from 'vitest';
-import {
-  consolidateCodeRanges,
-  inverseCodeRange,
-  isPointInCodeRange,
-  pointToPoint,
-} from './CodeRange';
-
-describe('CodeRange', () => {
-  test('should detect ranges', () => {
-    expect(
-      isPointInCodeRange([50, 50], pointToPoint(0, 0, 100, 100)),
-      'Should work within both ranges',
-    ).toBeTruthy();
-    expect(
-      isPointInCodeRange([50, 1000], pointToPoint(0, 0, 100, 100)),
-      'Should accept any column when within lines',
-    ).toBeTruthy();
-    expect(
-      isPointInCodeRange([50, 50], pointToPoint(0, 0, Infinity, Infinity)),
-      'Should work with infinity',
-    ).toBeTruthy();
-    expect(
-      isPointInCodeRange([100, 100], pointToPoint(0, 0, 100, 100)),
-      'Should reject points on the outer edge',
-    ).toBeFalsy();
-  });
-
-  test('should consolidate ranges that are completely contained', () => {
-    expect(
-      consolidateCodeRanges([
-        pointToPoint(0, 0, 100, 100),
-        pointToPoint(20, 0, 50, 0),
-      ]),
-    ).toEqual([pointToPoint(0, 0, 100, 100)]);
-    expect(
-      consolidateCodeRanges([
-        pointToPoint(20, 0, 50, 0),
-        pointToPoint(0, 0, 100, 100),
-      ]),
-    ).toEqual([pointToPoint(0, 0, 100, 100)]);
-  });
-
-  test('should combine ranges that overlap', () => {
-    expect(
-      consolidateCodeRanges([
-        pointToPoint(0, 5, 0, 10),
-        pointToPoint(0, 7, 0, 13),
-      ]),
-    ).toEqual([pointToPoint(0, 5, 0, 13)]);
-    expect(
-      consolidateCodeRanges([
-        pointToPoint(0, 7, 2, 13),
-        pointToPoint(0, 5, 2, 10),
-      ]),
-    ).toEqual([pointToPoint(0, 5, 2, 13)]);
-  });
-
-  test('should not combine ranges that do not overlap', () => {
-    expect(
-      consolidateCodeRanges([
-        pointToPoint(0, 5, 0, 10),
-        pointToPoint(0, 7, 0, 13),
-        pointToPoint(1, 5, 1, 10),
-      ]),
-    ).toEqual([pointToPoint(0, 5, 0, 13), pointToPoint(1, 5, 1, 10)]);
-  });
-
-  test('should invert empty ranges', () => {
-    expect(inverseCodeRange([])).toEqual([
-      pointToPoint(0, 0, Infinity, Infinity),
-    ]);
-  });
-});
+import {describe, expect, test} from 'vitest';
+import {
+  consolidateCodeRanges,
+  inverseCodeRange,
+  isPointInCodeRange,
+  pointToPoint,
+} from './CodeRange';
+
+describe('CodeRange', () => {
+  test('should detect ranges', () => {
+    expect(
+      isPointInCodeRange([50, 50], pointToPoint(0, 0, 100, 100)),
+      'Should work within both ranges',
+    ).toBeTruthy();
+    expect(
+      isPointInCodeRange([50, 1000], pointToPoint(0, 0, 100, 100)),
+      'Should accept any column when within lines',
+    ).toBeTruthy();
+    expect(
+      isPointInCodeRange([50, 50], pointToPoint(0, 0, Infinity, Infinity)),
+      'Should work with infinity',
+    ).toBeTruthy();
+    expect(
+      isPointInCodeRange([100, 100], pointToPoint(0, 0, 100, 100)),
+      'Should reject points on the outer edge',
+    ).toBeFalsy();
+  });
+
+  test('should consolidate ranges that are completely contained', () => {
+    expect(
+      consolidateCodeRanges([
+        pointToPoint(0, 0, 100, 100),
+        pointToPoint(20, 0, 50, 0),
+      ]),
+    ).toEqual([pointToPoint(0, 0, 100, 100)]);
+    expect(
+      consolidateCodeRanges([
+        pointToPoint(20, 0, 50, 0),
+        pointToPoint(0, 0, 100, 100),
+      ]),
+    ).toEqual([pointToPoint(0, 0, 100, 100)]);
+  });
+
+  test('should combine ranges that overlap', () => {
+    expect(
+      consolidateCodeRanges([
+        pointToPoint(0, 5, 0, 10),
+        pointToPoint(0, 7, 0, 13),
+      ]),
+    ).toEqual([pointToPoint(0, 5, 0, 13)]);
+    expect(
+      consolidateCodeRanges([
+        pointToPoint(0, 7, 2, 13),
+        pointToPoint(0, 5, 2, 10),
+      ]),
+    ).toEqual([pointToPoint(0, 5, 2, 13)]);
+  });
+
+  test('should not combine ranges that do not overlap', () => {
+    expect(
+      consolidateCodeRanges([
+        pointToPoint(0, 5, 0, 10),
+        pointToPoint(0, 7, 0, 13),
+        pointToPoint(1, 5, 1, 10),
+      ]),
+    ).toEqual([pointToPoint(0, 5, 0, 13), pointToPoint(1, 5, 1, 10)]);
+  });
+
+  test('should invert empty ranges', () => {
+    expect(inverseCodeRange([])).toEqual([
+      pointToPoint(0, 0, Infinity, Infinity),
+    ]);
+  });
+});

package/src/lib/code/CodeRange.ts

@@ -1,216 +1,216 @@
-export type CodePoint = [number, number];
-
-function isCodePoint(value: unknown): value is CodePoint {
-  return (
-    Array.isArray(value) &&
-    value.length === 2 &&
-    typeof value[0] === 'number' &&
-    typeof value[1] === 'number'
-  );
-}
-
-export type CodeRange = [CodePoint, CodePoint];
-
-export function isCodeRange(value: unknown): value is CodeRange {
-  return (
-    Array.isArray(value) &&
-    value.length === 2 &&
-    isCodePoint(value[0]) &&
-    isCodePoint(value[1])
-  );
-}
-
-/**
- * Create a code range that spans the given lines.
- *
- * @param from - The line from which the range starts.
- * @param to - The line at which the range ends. If omitted, the range will
- *             cover only one line.
- */
-export function lines(from: number, to?: number): CodeRange {
-  return [
-    [from, 0],
-    [to ?? from, Infinity],
-  ];
-}
-
-/**
- * Create a code range that highlights the given word.
- *
- * @param line - The line at which the word appears.
- * @param from - The column at which the word starts.
- * @param length - The length of the word. If omitted, the range will cover the
- *                 rest of the line.
- */
-export function word(line: number, from: number, length?: number): CodeRange {
-  return [
-    [line, from],
-    [line, from + (length ?? Infinity)],
-  ];
-}
-
-/**
- * Create a custom selection range.
- *
- * @param startLine - The line at which the selection starts.
- * @param startColumn - The column at which the selection starts.
- * @param endLine - The line at which the selection ends.
- * @param endColumn - The column at which the selection ends.
- */
-export function pointToPoint(
-  startLine: number,
-  startColumn: number,
-  endLine: number,
-  endColumn: number,
-): CodeRange {
-  return [
-    [startLine, startColumn],
-    [endLine, endColumn],
-  ];
-}
-
-export function isPointInCodeRange(point: CodePoint, range: CodeRange) {
-  const [y, x] = point;
-  const [[startLine, startColumn], [endLine, endColumn]] = range;
-  return (
-    ((y === startLine && x >= startColumn) || y > startLine) &&
-    ((y === endLine && x < endColumn) || y < endLine)
-  );
-}
-
-export function consolidateCodeRanges(ranges: CodeRange[]): CodeRange[] {
-  // Sort by start position
-  ranges.sort((a, b) => {
-    const lines = b[0][0] - a[0][0];
-    // Break ties on start column
-    if (lines === 0) {
-      return b[0][1] - a[0][1];
-    }
-    return lines;
-  });
-
-  const staged: CodeRange[] = [...ranges];
-  const results = [];
-  while (staged.length > 0) {
-    let current = staged.pop();
-    if (!current) {
-      continue;
-    }
-    const [[initStartLine, initStartColumn], [initEndLine, initEndColumn]] =
-      current;
-
-    for (const targetRange of staged) {
-      const [
-        [targetStartLine, targetStartColumn],
-        [targetEndLine, targetEndColumn],
-      ] = targetRange;
-      if (
-        isPointInCodeRange(targetRange[0], current) ||
-        isPointInCodeRange(targetRange[1], current)
-      ) {
-        staged.pop();
-
-        let startColumn;
-        if (initStartLine === targetStartLine) {
-          startColumn = Math.min(initStartColumn, targetStartColumn);
-        } else if (initStartLine < targetStartLine) {
-          startColumn = initStartColumn;
-        } else {
-          startColumn = targetStartColumn;
-        }
-
-        let endColumn;
-        if (initEndLine === targetEndLine) {
-          endColumn = Math.max(initEndColumn, targetEndColumn);
-        } else if (initEndLine > targetEndLine) {
-          endColumn = initEndColumn;
-        } else {
-          endColumn = targetEndColumn;
-        }
-        // Update the current to the consolidated one and get rid of the
-        // remaining instance of the unconsolidated target
-        current = [
-          [Math.min(initStartLine, targetStartLine), startColumn],
-          [Math.max(initEndLine, targetEndLine), endColumn],
-        ];
-      }
-    }
-    results.push(current);
-  }
-  return results;
-}
-
-export function inverseCodeRange(ranges: CodeRange[]): CodeRange[] {
-  if (ranges.length === 0) {
-    return [
-      [
-        [0, 0],
-        [Infinity, Infinity],
-      ],
-    ];
-  }
-  const firstRange = ranges[0];
-  const result: CodeRange[] = [];
-  for (let first = 0; first < ranges.length - 1; first++) {
-    const range1 = ranges[first];
-    const range2 = ranges[first + 1];
-    result.push([range1[1], range2[0]]);
-  }
-  const lastRange = ranges.slice(-1)[0];
-  return [
-    [[0, 0], firstRange[0]],
-    ...result,
-    [lastRange[1], [Infinity, Infinity]],
-  ];
-}
-
-/**
- * Find all code ranges that match the given pattern.
- *
- * @param code - The code to search in.
- * @param pattern - Either a string or a regular expression to search for.
- * @param limit - An optional limit on the number of ranges to find.
- */
-export function findAllCodeRanges(
-  code: string,
-  pattern: string | RegExp,
-  limit = Infinity,
-): CodeRange[] {
-  if (typeof pattern === 'string') {
-    pattern = new RegExp(pattern, 'g');
-  }
-
-  const matches = code.matchAll(pattern);
-  const ranges: CodeRange[] = [];
-  let index = 0;
-  let line = 0;
-  let column = 0;
-
-  for (const match of matches) {
-    if (match.index === undefined || ranges.length >= limit) {
-      continue;
-    }
-
-    let from: CodePoint = [line, column];
-    while (index <= code.length) {
-      if (index === match.index) {
-        from = [line, column];
-      }
-
-      if (index === match.index + match[0].length) {
-        ranges.push([from, [line, column]]);
-        break;
-      }
-
-      if (code[index] === '\n') {
-        line++;
-        column = 0;
-      } else {
-        column++;
-      }
-      index++;
-    }
-  }
-
-  return ranges;
-}
+export type CodePoint = [number, number];
+
+function isCodePoint(value: unknown): value is CodePoint {
+  return (
+    Array.isArray(value) &&
+    value.length === 2 &&
+    typeof value[0] === 'number' &&
+    typeof value[1] === 'number'
+  );
+}
+
+export type CodeRange = [CodePoint, CodePoint];
+
+export function isCodeRange(value: unknown): value is CodeRange {
+  return (
+    Array.isArray(value) &&
+    value.length === 2 &&
+    isCodePoint(value[0]) &&
+    isCodePoint(value[1])
+  );
+}
+
+/**
+ * Create a code range that spans the given lines.
+ *
+ * @param from - The line from which the range starts.
+ * @param to - The line at which the range ends. If omitted, the range will
+ *             cover only one line.
+ */
+export function lines(from: number, to?: number): CodeRange {
+  return [
+    [from, 0],
+    [to ?? from, Infinity],
+  ];
+}
+
+/**
+ * Create a code range that highlights the given word.
+ *
+ * @param line - The line at which the word appears.
+ * @param from - The column at which the word starts.
+ * @param length - The length of the word. If omitted, the range will cover the
+ *                 rest of the line.
+ */
+export function word(line: number, from: number, length?: number): CodeRange {
+  return [
+    [line, from],
+    [line, from + (length ?? Infinity)],
+  ];
+}
+
+/**
+ * Create a custom selection range.
+ *
+ * @param startLine - The line at which the selection starts.
+ * @param startColumn - The column at which the selection starts.
+ * @param endLine - The line at which the selection ends.
+ * @param endColumn - The column at which the selection ends.
+ */
+export function pointToPoint(
+  startLine: number,
+  startColumn: number,
+  endLine: number,
+  endColumn: number,
+): CodeRange {
+  return [
+    [startLine, startColumn],
+    [endLine, endColumn],
+  ];
+}
+
+export function isPointInCodeRange(point: CodePoint, range: CodeRange) {
+  const [y, x] = point;
+  const [[startLine, startColumn], [endLine, endColumn]] = range;
+  return (
+    ((y === startLine && x >= startColumn) || y > startLine) &&
+    ((y === endLine && x < endColumn) || y < endLine)
+  );
+}
+
+export function consolidateCodeRanges(ranges: CodeRange[]): CodeRange[] {
+  // Sort by start position
+  ranges.sort((a, b) => {
+    const lines = b[0][0] - a[0][0];
+    // Break ties on start column
+    if (lines === 0) {
+      return b[0][1] - a[0][1];
+    }
+    return lines;
+  });
+
+  const staged: CodeRange[] = [...ranges];
+  const results = [];
+  while (staged.length > 0) {
+    let current = staged.pop();
+    if (!current) {
+      continue;
+    }
+    const [[initStartLine, initStartColumn], [initEndLine, initEndColumn]] =
+      current;
+
+    for (const targetRange of staged) {
+      const [
+        [targetStartLine, targetStartColumn],
+        [targetEndLine, targetEndColumn],
+      ] = targetRange;
+      if (
+        isPointInCodeRange(targetRange[0], current) ||
+        isPointInCodeRange(targetRange[1], current)
+      ) {
+        staged.pop();
+
+        let startColumn;
+        if (initStartLine === targetStartLine) {
+          startColumn = Math.min(initStartColumn, targetStartColumn);
+        } else if (initStartLine < targetStartLine) {
+          startColumn = initStartColumn;
+        } else {
+          startColumn = targetStartColumn;
+        }
+
+        let endColumn;
+        if (initEndLine === targetEndLine) {
+          endColumn = Math.max(initEndColumn, targetEndColumn);
+        } else if (initEndLine > targetEndLine) {
+          endColumn = initEndColumn;
+        } else {
+          endColumn = targetEndColumn;
+        }
+        // Update the current to the consolidated one and get rid of the
+        // remaining instance of the unconsolidated target
+        current = [
+          [Math.min(initStartLine, targetStartLine), startColumn],
+          [Math.max(initEndLine, targetEndLine), endColumn],
+        ];
+      }
+    }
+    results.push(current);
+  }
+  return results;
+}
+
+export function inverseCodeRange(ranges: CodeRange[]): CodeRange[] {
+  if (ranges.length === 0) {
+    return [
+      [
+        [0, 0],
+        [Infinity, Infinity],
+      ],
+    ];
+  }
+  const firstRange = ranges[0];
+  const result: CodeRange[] = [];
+  for (let first = 0; first < ranges.length - 1; first++) {
+    const range1 = ranges[first];
+    const range2 = ranges[first + 1];
+    result.push([range1[1], range2[0]]);
+  }
+  const lastRange = ranges.slice(-1)[0];
+  return [
+    [[0, 0], firstRange[0]],
+    ...result,
+    [lastRange[1], [Infinity, Infinity]],
+  ];
+}
+
+/**
+ * Find all code ranges that match the given pattern.
+ *
+ * @param code - The code to search in.
+ * @param pattern - Either a string or a regular expression to search for.
+ * @param limit - An optional limit on the number of ranges to find.
+ */
+export function findAllCodeRanges(
+  code: string,
+  pattern: string | RegExp,
+  limit = Infinity,
+): CodeRange[] {
+  if (typeof pattern === 'string') {
+    pattern = new RegExp(pattern, 'g');
+  }
+
+  const matches = code.matchAll(pattern);
+  const ranges: CodeRange[] = [];
+  let index = 0;
+  let line = 0;
+  let column = 0;
+
+  for (const match of matches) {
+    if (match.index === undefined || ranges.length >= limit) {
+      continue;
+    }
+
+    let from: CodePoint = [line, column];
+    while (index <= code.length) {
+      if (index === match.index) {
+        from = [line, column];
+      }
+
+      if (index === match.index + match[0].length) {
+        ranges.push([from, [line, column]]);
+        break;
+      }
+
+      if (code[index] === '\n') {
+        line++;
+        column = 0;
+      } else {
+        column++;
+      }
+      index++;
+    }
+  }
+
+  return ranges;
+}