@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.ts

@@ -1,210 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { forEachAdjacent } from '../../../../../base/common/arrays';
-import { BugIndicatingError } from '../../../../../base/common/errors';
-import { OffsetRange } from '../../../core/ranges/offsetRange';
-
-/**
- * Represents a synchronous diff algorithm. Should be executed in a worker.
-*/
-export interface IDiffAlgorithm {
-	compute(sequence1: ISequence, sequence2: ISequence, timeout?: ITimeout): DiffAlgorithmResult;
-}
-
-export class DiffAlgorithmResult {
-	static trivial(seq1: ISequence, seq2: ISequence): DiffAlgorithmResult {
-		return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], false);
-	}
-
-	static trivialTimedOut(seq1: ISequence, seq2: ISequence): DiffAlgorithmResult {
-		return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], true);
-	}
-
-	constructor(
-		public readonly diffs: SequenceDiff[],
-		/**
-		 * Indicates if the time out was reached.
-		 * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.
-		 */
-		public readonly hitTimeout: boolean,
-	) { }
-}
-
-export class SequenceDiff {
-	public static invert(sequenceDiffs: SequenceDiff[], doc1Length: number): SequenceDiff[] {
-		const result: SequenceDiff[] = [];
-		forEachAdjacent(sequenceDiffs, (a, b) => {
-			result.push(SequenceDiff.fromOffsetPairs(
-				a ? a.getEndExclusives() : OffsetPair.zero,
-				b ? b.getStarts() : new OffsetPair(doc1Length, (a ? a.seq2Range.endExclusive - a.seq1Range.endExclusive : 0) + doc1Length)
-			));
-		});
-		return result;
-	}
-
-	public static fromOffsetPairs(start: OffsetPair, endExclusive: OffsetPair): SequenceDiff {
-		return new SequenceDiff(
-			new OffsetRange(start.offset1, endExclusive.offset1),
-			new OffsetRange(start.offset2, endExclusive.offset2),
-		);
-	}
-
-	public static assertSorted(sequenceDiffs: SequenceDiff[]): void {
-		let last: SequenceDiff | undefined = undefined;
-		for (const cur of sequenceDiffs) {
-			if (last) {
-				if (!(last.seq1Range.endExclusive <= cur.seq1Range.start && last.seq2Range.endExclusive <= cur.seq2Range.start)) {
-					throw new BugIndicatingError('Sequence diffs must be sorted');
-				}
-			}
-			last = cur;
-		}
-	}
-
-	constructor(
-		public readonly seq1Range: OffsetRange,
-		public readonly seq2Range: OffsetRange,
-	) { }
-
-	public swap(): SequenceDiff {
-		return new SequenceDiff(this.seq2Range, this.seq1Range);
-	}
-
-	public toString(): string {
-		return `${this.seq1Range} <-> ${this.seq2Range}`;
-	}
-
-	public join(other: SequenceDiff): SequenceDiff {
-		return new SequenceDiff(this.seq1Range.join(other.seq1Range), this.seq2Range.join(other.seq2Range));
-	}
-
-	public delta(offset: number): SequenceDiff {
-		if (offset === 0) {
-			return this;
-		}
-		return new SequenceDiff(this.seq1Range.delta(offset), this.seq2Range.delta(offset));
-	}
-
-	public deltaStart(offset: number): SequenceDiff {
-		if (offset === 0) {
-			return this;
-		}
-		return new SequenceDiff(this.seq1Range.deltaStart(offset), this.seq2Range.deltaStart(offset));
-	}
-
-	public deltaEnd(offset: number): SequenceDiff {
-		if (offset === 0) {
-			return this;
-		}
-		return new SequenceDiff(this.seq1Range.deltaEnd(offset), this.seq2Range.deltaEnd(offset));
-	}
-
-	public intersectsOrTouches(other: SequenceDiff): boolean {
-		return this.seq1Range.intersectsOrTouches(other.seq1Range) || this.seq2Range.intersectsOrTouches(other.seq2Range);
-	}
-
-	public intersect(other: SequenceDiff): SequenceDiff | undefined {
-		const i1 = this.seq1Range.intersect(other.seq1Range);
-		const i2 = this.seq2Range.intersect(other.seq2Range);
-		if (!i1 || !i2) {
-			return undefined;
-		}
-		return new SequenceDiff(i1, i2);
-	}
-
-	public getStarts(): OffsetPair {
-		return new OffsetPair(this.seq1Range.start, this.seq2Range.start);
-	}
-
-	public getEndExclusives(): OffsetPair {
-		return new OffsetPair(this.seq1Range.endExclusive, this.seq2Range.endExclusive);
-	}
-}
-
-export class OffsetPair {
-	public static readonly zero = new OffsetPair(0, 0);
-	public static readonly max = new OffsetPair(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-
-	constructor(
-		public readonly offset1: number,
-		public readonly offset2: number,
-	) {
-	}
-
-	public toString(): string {
-		return `${this.offset1} <-> ${this.offset2}`;
-	}
-
-	public delta(offset: number): OffsetPair {
-		if (offset === 0) {
-			return this;
-		}
-		return new OffsetPair(this.offset1 + offset, this.offset2 + offset);
-	}
-
-	public equals(other: OffsetPair): boolean {
-		return this.offset1 === other.offset1 && this.offset2 === other.offset2;
-	}
-}
-
-export interface ISequence {
-	getElement(offset: number): number;
-	get length(): number;
-
-	/**
-	 * The higher the score, the better that offset can be used to split the sequence.
-	 * Is used to optimize insertions.
-	 * Must not be negative.
-	*/
-	getBoundaryScore?(length: number): number;
-
-	/**
-	 * For line sequences, getElement returns a number representing trimmed lines.
-	 * This however checks equality for the original lines.
-	 * It prevents shifting to less matching lines.
-	 */
-	isStronglyEqual(offset1: number, offset2: number): boolean;
-}
-
-export interface ITimeout {
-	isValid(): boolean;
-}
-
-export class InfiniteTimeout implements ITimeout {
-	public static instance = new InfiniteTimeout();
-
-	isValid(): boolean {
-		return true;
-	}
-}
-
-export class DateTimeout implements ITimeout {
-	private readonly startTime = Date.now();
-	private valid = true;
-
-	constructor(private timeout: number) {
-		if (timeout <= 0) {
-			throw new BugIndicatingError('timeout must be positive');
-		}
-	}
-
-	// Recommendation: Set a log-point `{this.disable()}` in the body
-	public isValid(): boolean {
-		const valid = Date.now() - this.startTime < this.timeout;
-		if (!valid && this.valid) {
-			this.valid = false; // timeout reached
-		}
-		return this.valid;
-	}
-
-	public disable() {
-		this.timeout = Number.MAX_SAFE_INTEGER;
-		this.isValid = () => true;
-		this.valid = true;
-	}
-}

package/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/dynamicProgrammingDiffing.ts

@@ -1,109 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { OffsetRange } from '../../../core/ranges/offsetRange';
-import { IDiffAlgorithm, SequenceDiff, ISequence, ITimeout, InfiniteTimeout, DiffAlgorithmResult } from './diffAlgorithm';
-import { Array2D } from '../utils';
-
-/**
- * A O(MN) diffing algorithm that supports a score function.
- * The algorithm can be improved by processing the 2d array diagonally.
-*/
-export class DynamicProgrammingDiffing implements IDiffAlgorithm {
-	compute(sequence1: ISequence, sequence2: ISequence, timeout: ITimeout = InfiniteTimeout.instance, equalityScore?: (offset1: number, offset2: number) => number): DiffAlgorithmResult {
-		if (sequence1.length === 0 || sequence2.length === 0) {
-			return DiffAlgorithmResult.trivial(sequence1, sequence2);
-		}
-
-		/**
-		 * lcsLengths.get(i, j): Length of the longest common subsequence of sequence1.substring(0, i + 1) and sequence2.substring(0, j + 1).
-		 */
-		const lcsLengths = new Array2D<number>(sequence1.length, sequence2.length);
-		const directions = new Array2D<number>(sequence1.length, sequence2.length);
-		const lengths = new Array2D<number>(sequence1.length, sequence2.length);
-
-		// ==== Initializing lcsLengths ====
-		for (let s1 = 0; s1 < sequence1.length; s1++) {
-			for (let s2 = 0; s2 < sequence2.length; s2++) {
-				if (!timeout.isValid()) {
-					return DiffAlgorithmResult.trivialTimedOut(sequence1, sequence2);
-				}
-
-				const horizontalLen = s1 === 0 ? 0 : lcsLengths.get(s1 - 1, s2);
-				const verticalLen = s2 === 0 ? 0 : lcsLengths.get(s1, s2 - 1);
-
-				let extendedSeqScore: number;
-				if (sequence1.getElement(s1) === sequence2.getElement(s2)) {
-					if (s1 === 0 || s2 === 0) {
-						extendedSeqScore = 0;
-					} else {
-						extendedSeqScore = lcsLengths.get(s1 - 1, s2 - 1);
-					}
-					if (s1 > 0 && s2 > 0 && directions.get(s1 - 1, s2 - 1) === 3) {
-						// Prefer consecutive diagonals
-						extendedSeqScore += lengths.get(s1 - 1, s2 - 1);
-					}
-					extendedSeqScore += (equalityScore ? equalityScore(s1, s2) : 1);
-				} else {
-					extendedSeqScore = -1;
-				}
-
-				const newValue = Math.max(horizontalLen, verticalLen, extendedSeqScore);
-
-				if (newValue === extendedSeqScore) {
-					// Prefer diagonals
-					const prevLen = s1 > 0 && s2 > 0 ? lengths.get(s1 - 1, s2 - 1) : 0;
-					lengths.set(s1, s2, prevLen + 1);
-					directions.set(s1, s2, 3);
-				} else if (newValue === horizontalLen) {
-					lengths.set(s1, s2, 0);
-					directions.set(s1, s2, 1);
-				} else if (newValue === verticalLen) {
-					lengths.set(s1, s2, 0);
-					directions.set(s1, s2, 2);
-				}
-
-				lcsLengths.set(s1, s2, newValue);
-			}
-		}
-
-		// ==== Backtracking ====
-		const result: SequenceDiff[] = [];
-		let lastAligningPosS1: number = sequence1.length;
-		let lastAligningPosS2: number = sequence2.length;
-
-		function reportDecreasingAligningPositions(s1: number, s2: number): void {
-			if (s1 + 1 !== lastAligningPosS1 || s2 + 1 !== lastAligningPosS2) {
-				result.push(new SequenceDiff(
-					new OffsetRange(s1 + 1, lastAligningPosS1),
-					new OffsetRange(s2 + 1, lastAligningPosS2),
-				));
-			}
-			lastAligningPosS1 = s1;
-			lastAligningPosS2 = s2;
-		}
-
-		let s1 = sequence1.length - 1;
-		let s2 = sequence2.length - 1;
-		while (s1 >= 0 && s2 >= 0) {
-			if (directions.get(s1, s2) === 3) {
-				reportDecreasingAligningPositions(s1, s2);
-				s1--;
-				s2--;
-			} else {
-				if (directions.get(s1, s2) === 1) {
-					s1--;
-				} else {
-					s2--;
-				}
-			}
-		}
-		reportDecreasingAligningPositions(-1, -1);
-		result.reverse();
-		return new DiffAlgorithmResult(result, false);
-	}
-}

package/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/myersDiffAlgorithm.ts

@@ -1,178 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { OffsetRange } from '../../../core/ranges/offsetRange';
-import { DiffAlgorithmResult, IDiffAlgorithm, ISequence, ITimeout, InfiniteTimeout, SequenceDiff } from './diffAlgorithm';
-
-/**
- * An O(ND) diff algorithm that has a quadratic space worst-case complexity.
-*/
-export class MyersDiffAlgorithm implements IDiffAlgorithm {
-	compute(seq1: ISequence, seq2: ISequence, timeout: ITimeout = InfiniteTimeout.instance): DiffAlgorithmResult {
-		// These are common special cases.
-		// The early return improves performance dramatically.
-		if (seq1.length === 0 || seq2.length === 0) {
-			return DiffAlgorithmResult.trivial(seq1, seq2);
-		}
-
-		const seqX = seq1; // Text on the x axis
-		const seqY = seq2; // Text on the y axis
-
-		function getXAfterSnake(x: number, y: number): number {
-			while (x < seqX.length && y < seqY.length && seqX.getElement(x) === seqY.getElement(y)) {
-				x++;
-				y++;
-			}
-			return x;
-		}
-
-		let d = 0;
-		// V[k]: X value of longest d-line that ends in diagonal k.
-		// d-line: path from (0,0) to (x,y) that uses exactly d non-diagonals.
-		// diagonal k: Set of points (x,y) with x-y = k.
-		// k=1 -> (1,0),(2,1)
-		const V = new FastInt32Array();
-		V.set(0, getXAfterSnake(0, 0));
-
-		const paths = new FastArrayNegativeIndices<SnakePath | null>();
-		paths.set(0, V.get(0) === 0 ? null : new SnakePath(null, 0, 0, V.get(0)));
-
-		let k = 0;
-
-		loop: while (true) {
-			d++;
-			if (!timeout.isValid()) {
-				return DiffAlgorithmResult.trivialTimedOut(seqX, seqY);
-			}
-			// The paper has `for (k = -d; k <= d; k += 2)`, but we can ignore diagonals that cannot influence the result.
-			const lowerBound = -Math.min(d, seqY.length + (d % 2));
-			const upperBound = Math.min(d, seqX.length + (d % 2));
-			for (k = lowerBound; k <= upperBound; k += 2) {
-				let step = 0;
-				// We can use the X values of (d-1)-lines to compute X value of the longest d-lines.
-				const maxXofDLineTop = k === upperBound ? -1 : V.get(k + 1); // We take a vertical non-diagonal (add a symbol in seqX)
-				const maxXofDLineLeft = k === lowerBound ? -1 : V.get(k - 1) + 1; // We take a horizontal non-diagonal (+1 x) (delete a symbol in seqX)
-				step++;
-				const x = Math.min(Math.max(maxXofDLineTop, maxXofDLineLeft), seqX.length);
-				const y = x - k;
-				step++;
-				if (x > seqX.length || y > seqY.length) {
-					// This diagonal is irrelevant for the result.
-					// TODO: Don't pay the cost for this in the next iteration.
-					continue;
-				}
-				const newMaxX = getXAfterSnake(x, y);
-				V.set(k, newMaxX);
-				const lastPath = x === maxXofDLineTop ? paths.get(k + 1) : paths.get(k - 1);
-				paths.set(k, newMaxX !== x ? new SnakePath(lastPath, x, y, newMaxX - x) : lastPath);
-
-				if (V.get(k) === seqX.length && V.get(k) - k === seqY.length) {
-					break loop;
-				}
-			}
-		}
-
-		let path = paths.get(k);
-		const result: SequenceDiff[] = [];
-		let lastAligningPosS1: number = seqX.length;
-		let lastAligningPosS2: number = seqY.length;
-
-		while (true) {
-			const endX = path ? path.x + path.length : 0;
-			const endY = path ? path.y + path.length : 0;
-
-			if (endX !== lastAligningPosS1 || endY !== lastAligningPosS2) {
-				result.push(new SequenceDiff(
-					new OffsetRange(endX, lastAligningPosS1),
-					new OffsetRange(endY, lastAligningPosS2),
-				));
-			}
-			if (!path) {
-				break;
-			}
-			lastAligningPosS1 = path.x;
-			lastAligningPosS2 = path.y;
-
-			path = path.prev;
-		}
-
-		result.reverse();
-		return new DiffAlgorithmResult(result, false);
-	}
-}
-
-class SnakePath {
-	constructor(
-		public readonly prev: SnakePath | null,
-		public readonly x: number,
-		public readonly y: number,
-		public readonly length: number
-	) {
-	}
-}
-
-/**
- * An array that supports fast negative indices.
-*/
-class FastInt32Array {
-	private positiveArr: Int32Array = new Int32Array(10);
-	private negativeArr: Int32Array = new Int32Array(10);
-
-	get(idx: number): number {
-		if (idx < 0) {
-			idx = -idx - 1;
-			return this.negativeArr[idx];
-		} else {
-			return this.positiveArr[idx];
-		}
-	}
-
-	set(idx: number, value: number): void {
-		if (idx < 0) {
-			idx = -idx - 1;
-			if (idx >= this.negativeArr.length) {
-				const arr = this.negativeArr;
-				this.negativeArr = new Int32Array(arr.length * 2);
-				this.negativeArr.set(arr);
-			}
-			this.negativeArr[idx] = value;
-		} else {
-			if (idx >= this.positiveArr.length) {
-				const arr = this.positiveArr;
-				this.positiveArr = new Int32Array(arr.length * 2);
-				this.positiveArr.set(arr);
-			}
-			this.positiveArr[idx] = value;
-		}
-	}
-}
-
-/**
- * An array that supports fast negative indices.
-*/
-class FastArrayNegativeIndices<T> {
-	private readonly positiveArr: T[] = [];
-	private readonly negativeArr: T[] = [];
-
-	get(idx: number): T {
-		if (idx < 0) {
-			idx = -idx - 1;
-			return this.negativeArr[idx];
-		} else {
-			return this.positiveArr[idx];
-		}
-	}
-
-	set(idx: number, value: T): void {
-		if (idx < 0) {
-			idx = -idx - 1;
-			this.negativeArr[idx] = value;
-		} else {
-			this.positiveArr[idx] = value;
-		}
-	}
-}