@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/editor/common/core/edits/textEdit.ts

@@ -1,411 +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 { compareBy, equals } from '../../../../base/common/arrays';
-import { assertFn, checkAdjacentItems } from '../../../../base/common/assert';
-import { BugIndicatingError } from '../../../../base/common/errors';
-import { commonPrefixLength, commonSuffixLength } from '../../../../base/common/strings';
-import { ISingleEditOperation } from '../editOperation';
-import { BaseStringEdit, StringReplacement } from './stringEdit';
-import { Position } from '../position';
-import { Range } from '../range';
-import { TextLength } from '../text/textLength';
-import { AbstractText, StringText } from '../text/abstractText';
-
-export class TextEdit {
-	public static fromStringEdit(edit: BaseStringEdit, initialState: AbstractText): TextEdit {
-		const edits = edit.replacements.map(e => TextReplacement.fromStringReplacement(e, initialState));
-		return new TextEdit(edits);
-	}
-
-	public static replace(originalRange: Range, newText: string): TextEdit {
-		return new TextEdit([new TextReplacement(originalRange, newText)]);
-	}
-
-	public static delete(range: Range): TextEdit {
-		return new TextEdit([new TextReplacement(range, '')]);
-	}
-
-	public static insert(position: Position, newText: string): TextEdit {
-		return new TextEdit([new TextReplacement(Range.fromPositions(position, position), newText)]);
-	}
-
-	public static fromParallelReplacementsUnsorted(replacements: readonly TextReplacement[]): TextEdit {
-		const r = replacements.slice().sort(compareBy(i => i.range, Range.compareRangesUsingStarts));
-		return new TextEdit(r);
-	}
-
-	constructor(
-		public readonly replacements: readonly TextReplacement[]
-	) {
-		assertFn(() => checkAdjacentItems(replacements, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));
-	}
-
-	/**
-	 * Joins touching edits and removes empty edits.
-	 */
-	normalize(): TextEdit {
-		const replacements: TextReplacement[] = [];
-		for (const r of this.replacements) {
-			if (replacements.length > 0 && replacements[replacements.length - 1].range.getEndPosition().equals(r.range.getStartPosition())) {
-				const last = replacements[replacements.length - 1];
-				replacements[replacements.length - 1] = new TextReplacement(last.range.plusRange(r.range), last.text + r.text);
-			} else if (!r.isEmpty) {
-				replacements.push(r);
-			}
-		}
-		return new TextEdit(replacements);
-	}
-
-	mapPosition(position: Position): Position | Range {
-		let lineDelta = 0;
-		let curLine = 0;
-		let columnDeltaInCurLine = 0;
-
-		for (const replacement of this.replacements) {
-			const start = replacement.range.getStartPosition();
-
-			if (position.isBeforeOrEqual(start)) {
-				break;
-			}
-
-			const end = replacement.range.getEndPosition();
-			const len = TextLength.ofText(replacement.text);
-			if (position.isBefore(end)) {
-				const startPos = new Position(start.lineNumber + lineDelta, start.column + (start.lineNumber + lineDelta === curLine ? columnDeltaInCurLine : 0));
-				const endPos = len.addToPosition(startPos);
-				return rangeFromPositions(startPos, endPos);
-			}
-
-			if (start.lineNumber + lineDelta !== curLine) {
-				columnDeltaInCurLine = 0;
-			}
-
-			lineDelta += len.lineCount - (replacement.range.endLineNumber - replacement.range.startLineNumber);
-
-			if (len.lineCount === 0) {
-				if (end.lineNumber !== start.lineNumber) {
-					columnDeltaInCurLine += len.columnCount - (end.column - 1);
-				} else {
-					columnDeltaInCurLine += len.columnCount - (end.column - start.column);
-				}
-			} else {
-				columnDeltaInCurLine = len.columnCount;
-			}
-			curLine = end.lineNumber + lineDelta;
-		}
-
-		return new Position(position.lineNumber + lineDelta, position.column + (position.lineNumber + lineDelta === curLine ? columnDeltaInCurLine : 0));
-	}
-
-	mapRange(range: Range): Range {
-		function getStart(p: Position | Range) {
-			return p instanceof Position ? p : p.getStartPosition();
-		}
-
-		function getEnd(p: Position | Range) {
-			return p instanceof Position ? p : p.getEndPosition();
-		}
-
-		const start = getStart(this.mapPosition(range.getStartPosition()));
-		const end = getEnd(this.mapPosition(range.getEndPosition()));
-
-		return rangeFromPositions(start, end);
-	}
-
-	// TODO: `doc` is not needed for this!
-	inverseMapPosition(positionAfterEdit: Position, doc: AbstractText): Position | Range {
-		const reversed = this.inverse(doc);
-		return reversed.mapPosition(positionAfterEdit);
-	}
-
-	inverseMapRange(range: Range, doc: AbstractText): Range {
-		const reversed = this.inverse(doc);
-		return reversed.mapRange(range);
-	}
-
-	apply(text: AbstractText): string {
-		let result = '';
-		let lastEditEnd = new Position(1, 1);
-		for (const replacement of this.replacements) {
-			const editRange = replacement.range;
-			const editStart = editRange.getStartPosition();
-			const editEnd = editRange.getEndPosition();
-
-			const r = rangeFromPositions(lastEditEnd, editStart);
-			if (!r.isEmpty()) {
-				result += text.getValueOfRange(r);
-			}
-			result += replacement.text;
-			lastEditEnd = editEnd;
-		}
-		const r = rangeFromPositions(lastEditEnd, text.endPositionExclusive);
-		if (!r.isEmpty()) {
-			result += text.getValueOfRange(r);
-		}
-		return result;
-	}
-
-	applyToString(str: string): string {
-		const strText = new StringText(str);
-		return this.apply(strText);
-	}
-
-	inverse(doc: AbstractText): TextEdit {
-		const ranges = this.getNewRanges();
-		return new TextEdit(this.replacements.map((e, idx) => new TextReplacement(ranges[idx], doc.getValueOfRange(e.range))));
-	}
-
-	getNewRanges(): Range[] {
-		const newRanges: Range[] = [];
-		let previousEditEndLineNumber = 0;
-		let lineOffset = 0;
-		let columnOffset = 0;
-		for (const replacement of this.replacements) {
-			const textLength = TextLength.ofText(replacement.text);
-			const newRangeStart = Position.lift({
-				lineNumber: replacement.range.startLineNumber + lineOffset,
-				column: replacement.range.startColumn + (replacement.range.startLineNumber === previousEditEndLineNumber ? columnOffset : 0)
-			});
-			const newRange = textLength.createRange(newRangeStart);
-			newRanges.push(newRange);
-			lineOffset = newRange.endLineNumber - replacement.range.endLineNumber;
-			columnOffset = newRange.endColumn - replacement.range.endColumn;
-			previousEditEndLineNumber = replacement.range.endLineNumber;
-		}
-		return newRanges;
-	}
-
-	toReplacement(text: AbstractText): TextReplacement {
-		if (this.replacements.length === 0) { throw new BugIndicatingError(); }
-		if (this.replacements.length === 1) { return this.replacements[0]; }
-
-		const startPos = this.replacements[0].range.getStartPosition();
-		const endPos = this.replacements[this.replacements.length - 1].range.getEndPosition();
-
-		let newText = '';
-
-		for (let i = 0; i < this.replacements.length; i++) {
-			const curEdit = this.replacements[i];
-			newText += curEdit.text;
-			if (i < this.replacements.length - 1) {
-				const nextEdit = this.replacements[i + 1];
-				const gapRange = Range.fromPositions(curEdit.range.getEndPosition(), nextEdit.range.getStartPosition());
-				const gapText = text.getValueOfRange(gapRange);
-				newText += gapText;
-			}
-		}
-		return new TextReplacement(Range.fromPositions(startPos, endPos), newText);
-	}
-
-	equals(other: TextEdit): boolean {
-		return equals(this.replacements, other.replacements, (a, b) => a.equals(b));
-	}
-
-	toString(text: AbstractText | string | undefined): string {
-		if (text === undefined) {
-			return this.replacements.map(edit => edit.toString()).join('\n');
-		}
-
-		if (typeof text === 'string') {
-			return this.toString(new StringText(text));
-		}
-
-		if (this.replacements.length === 0) {
-			return '';
-		}
-
-		return this.replacements.map(r => {
-			const maxLength = 10;
-			const originalText = text.getValueOfRange(r.range);
-
-			// Get text before the edit
-			const beforeRange = Range.fromPositions(
-				new Position(Math.max(1, r.range.startLineNumber - 1), 1),
-				r.range.getStartPosition()
-			);
-			let beforeText = text.getValueOfRange(beforeRange);
-			if (beforeText.length > maxLength) {
-				beforeText = '...' + beforeText.substring(beforeText.length - maxLength);
-			}
-
-			// Get text after the edit
-			const afterRange = Range.fromPositions(
-				r.range.getEndPosition(),
-				new Position(r.range.endLineNumber + 1, 1)
-			);
-			let afterText = text.getValueOfRange(afterRange);
-			if (afterText.length > maxLength) {
-				afterText = afterText.substring(0, maxLength) + '...';
-			}
-
-			// Format the replaced text
-			let replacedText = originalText;
-			if (replacedText.length > maxLength) {
-				const halfMax = Math.floor(maxLength / 2);
-				replacedText = replacedText.substring(0, halfMax) + '...' +
-					replacedText.substring(replacedText.length - halfMax);
-			}
-
-			// Format the new text
-			let newText = r.text;
-			if (newText.length > maxLength) {
-				const halfMax = Math.floor(maxLength / 2);
-				newText = newText.substring(0, halfMax) + '...' +
-					newText.substring(newText.length - halfMax);
-			}
-
-			if (replacedText.length === 0) {
-				// allow-any-unicode-next-line
-				return `${beforeText}❰${newText}❱${afterText}`;
-			}
-			// allow-any-unicode-next-line
-			return `${beforeText}❰${replacedText}↦${newText}❱${afterText}`;
-		}).join('\n');
-	}
-}
-
-export class TextReplacement {
-	public static joinReplacements(replacements: TextReplacement[], initialValue: AbstractText): TextReplacement {
-		if (replacements.length === 0) { throw new BugIndicatingError(); }
-		if (replacements.length === 1) { return replacements[0]; }
-
-		const startPos = replacements[0].range.getStartPosition();
-		const endPos = replacements[replacements.length - 1].range.getEndPosition();
-
-		let newText = '';
-
-		for (let i = 0; i < replacements.length; i++) {
-			const curEdit = replacements[i];
-			newText += curEdit.text;
-			if (i < replacements.length - 1) {
-				const nextEdit = replacements[i + 1];
-				const gapRange = Range.fromPositions(curEdit.range.getEndPosition(), nextEdit.range.getStartPosition());
-				const gapText = initialValue.getValueOfRange(gapRange);
-				newText += gapText;
-			}
-		}
-		return new TextReplacement(Range.fromPositions(startPos, endPos), newText);
-	}
-
-	public static fromStringReplacement(replacement: StringReplacement, initialState: AbstractText): TextReplacement {
-		return new TextReplacement(initialState.getTransformer().getRange(replacement.replaceRange), replacement.newText);
-	}
-
-	public static delete(range: Range): TextReplacement {
-		return new TextReplacement(range, '');
-	}
-
-	constructor(
-		public readonly range: Range,
-		public readonly text: string,
-	) {
-	}
-
-	get isEmpty(): boolean {
-		return this.range.isEmpty() && this.text.length === 0;
-	}
-
-	static equals(first: TextReplacement, second: TextReplacement) {
-		return first.range.equalsRange(second.range) && first.text === second.text;
-	}
-
-	public toSingleEditOperation(): ISingleEditOperation {
-		return {
-			range: this.range,
-			text: this.text,
-		};
-	}
-
-	public toEdit(): TextEdit {
-		return new TextEdit([this]);
-	}
-
-	public equals(other: TextReplacement): boolean {
-		return TextReplacement.equals(this, other);
-	}
-
-	public extendToCoverRange(range: Range, initialValue: AbstractText): TextReplacement {
-		if (this.range.containsRange(range)) { return this; }
-
-		const newRange = this.range.plusRange(range);
-		const textBefore = initialValue.getValueOfRange(Range.fromPositions(newRange.getStartPosition(), this.range.getStartPosition()));
-		const textAfter = initialValue.getValueOfRange(Range.fromPositions(this.range.getEndPosition(), newRange.getEndPosition()));
-		const newText = textBefore + this.text + textAfter;
-		return new TextReplacement(newRange, newText);
-	}
-
-	public extendToFullLine(initialValue: AbstractText): TextReplacement {
-		const newRange = new Range(
-			this.range.startLineNumber,
-			1,
-			this.range.endLineNumber,
-			initialValue.getTransformer().getLineLength(this.range.endLineNumber) + 1
-		);
-		return this.extendToCoverRange(newRange, initialValue);
-	}
-
-	public removeCommonPrefixAndSuffix(text: AbstractText): TextReplacement {
-		const prefix = this.removeCommonPrefix(text);
-		const suffix = prefix.removeCommonSuffix(text);
-		return suffix;
-	}
-
-	public removeCommonPrefix(text: AbstractText): TextReplacement {
-		const normalizedOriginalText = text.getValueOfRange(this.range).replaceAll('\r\n', '\n');
-		const normalizedModifiedText = this.text.replaceAll('\r\n', '\n');
-
-		const commonPrefixLen = commonPrefixLength(normalizedOriginalText, normalizedModifiedText);
-		const start = TextLength.ofText(normalizedOriginalText.substring(0, commonPrefixLen))
-			.addToPosition(this.range.getStartPosition());
-
-		const newText = normalizedModifiedText.substring(commonPrefixLen);
-		const range = Range.fromPositions(start, this.range.getEndPosition());
-		return new TextReplacement(range, newText);
-	}
-
-	public removeCommonSuffix(text: AbstractText): TextReplacement {
-		const normalizedOriginalText = text.getValueOfRange(this.range).replaceAll('\r\n', '\n');
-		const normalizedModifiedText = this.text.replaceAll('\r\n', '\n');
-
-		const commonSuffixLen = commonSuffixLength(normalizedOriginalText, normalizedModifiedText);
-		const end = TextLength.ofText(normalizedOriginalText.substring(0, normalizedOriginalText.length - commonSuffixLen))
-			.addToPosition(this.range.getStartPosition());
-
-		const newText = normalizedModifiedText.substring(0, normalizedModifiedText.length - commonSuffixLen);
-		const range = Range.fromPositions(this.range.getStartPosition(), end);
-		return new TextReplacement(range, newText);
-	}
-
-	public isEffectiveDeletion(text: AbstractText): boolean {
-		let newText = this.text.replaceAll('\r\n', '\n');
-		let existingText = text.getValueOfRange(this.range).replaceAll('\r\n', '\n');
-		const l = commonPrefixLength(newText, existingText);
-		newText = newText.substring(l);
-		existingText = existingText.substring(l);
-		const r = commonSuffixLength(newText, existingText);
-		newText = newText.substring(0, newText.length - r);
-		existingText = existingText.substring(0, existingText.length - r);
-
-		return newText === '';
-	}
-
-	public toString(): string {
-		const start = this.range.getStartPosition();
-		const end = this.range.getEndPosition();
-		return `(${start.lineNumber},${start.column} -> ${end.lineNumber},${end.column}): "${this.text}"`;
-	}
-}
-
-function rangeFromPositions(start: Position, end: Position): Range {
-	if (start.lineNumber === end.lineNumber && start.column === Number.MAX_SAFE_INTEGER) {
-		return Range.fromPositions(end, end);
-	} else if (!start.isBeforeOrEqual(end)) {
-		throw new BugIndicatingError('start must be before end');
-	}
-	return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
-}

package/src/_internal/util/vs/editor/common/core/position.ts

@@ -1,186 +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.
- *--------------------------------------------------------------------------------------------*/
-
-/**
- * A position in the editor. This interface is suitable for serialization.
- */
-export interface IPosition {
-	/**
-	 * line number (starts at 1)
-	 */
-	readonly lineNumber: number;
-	/**
-	 * column (the first character in a line is between column 1 and column 2)
-	 */
-	readonly column: number;
-}
-
-/**
- * A position in the editor.
- */
-export class Position {
-	/**
-	 * line number (starts at 1)
-	 */
-	public readonly lineNumber: number;
-	/**
-	 * column (the first character in a line is between column 1 and column 2)
-	 */
-	public readonly column: number;
-
-	constructor(lineNumber: number, column: number) {
-		this.lineNumber = lineNumber;
-		this.column = column;
-	}
-
-	/**
-	 * Create a new position from this position.
-	 *
-	 * @param newLineNumber new line number
-	 * @param newColumn new column
-	 */
-	with(newLineNumber: number = this.lineNumber, newColumn: number = this.column): Position {
-		if (newLineNumber === this.lineNumber && newColumn === this.column) {
-			return this;
-		} else {
-			return new Position(newLineNumber, newColumn);
-		}
-	}
-
-	/**
-	 * Derive a new position from this position.
-	 *
-	 * @param deltaLineNumber line number delta
-	 * @param deltaColumn column delta
-	 */
-	delta(deltaLineNumber: number = 0, deltaColumn: number = 0): Position {
-		return this.with(Math.max(1, this.lineNumber + deltaLineNumber), Math.max(1, this.column + deltaColumn));
-	}
-
-	/**
-	 * Test if this position equals other position
-	 */
-	public equals(other: IPosition): boolean {
-		return Position.equals(this, other);
-	}
-
-	/**
-	 * Test if position `a` equals position `b`
-	 */
-	public static equals(a: IPosition | null, b: IPosition | null): boolean {
-		if (!a && !b) {
-			return true;
-		}
-		return (
-			!!a &&
-			!!b &&
-			a.lineNumber === b.lineNumber &&
-			a.column === b.column
-		);
-	}
-
-	/**
-	 * Test if this position is before other position.
-	 * If the two positions are equal, the result will be false.
-	 */
-	public isBefore(other: IPosition): boolean {
-		return Position.isBefore(this, other);
-	}
-
-	/**
-	 * Test if position `a` is before position `b`.
-	 * If the two positions are equal, the result will be false.
-	 */
-	public static isBefore(a: IPosition, b: IPosition): boolean {
-		if (a.lineNumber < b.lineNumber) {
-			return true;
-		}
-		if (b.lineNumber < a.lineNumber) {
-			return false;
-		}
-		return a.column < b.column;
-	}
-
-	/**
-	 * Test if this position is before other position.
-	 * If the two positions are equal, the result will be true.
-	 */
-	public isBeforeOrEqual(other: IPosition): boolean {
-		return Position.isBeforeOrEqual(this, other);
-	}
-
-	/**
-	 * Test if position `a` is before position `b`.
-	 * If the two positions are equal, the result will be true.
-	 */
-	public static isBeforeOrEqual(a: IPosition, b: IPosition): boolean {
-		if (a.lineNumber < b.lineNumber) {
-			return true;
-		}
-		if (b.lineNumber < a.lineNumber) {
-			return false;
-		}
-		return a.column <= b.column;
-	}
-
-	/**
-	 * A function that compares positions, useful for sorting
-	 */
-	public static compare(a: IPosition, b: IPosition): number {
-		const aLineNumber = a.lineNumber | 0;
-		const bLineNumber = b.lineNumber | 0;
-
-		if (aLineNumber === bLineNumber) {
-			const aColumn = a.column | 0;
-			const bColumn = b.column | 0;
-			return aColumn - bColumn;
-		}
-
-		return aLineNumber - bLineNumber;
-	}
-
-	/**
-	 * Clone this position.
-	 */
-	public clone(): Position {
-		return new Position(this.lineNumber, this.column);
-	}
-
-	/**
-	 * Convert to a human-readable representation.
-	 */
-	public toString(): string {
-		return '(' + this.lineNumber + ',' + this.column + ')';
-	}
-
-	// ---
-
-	/**
-	 * Create a `Position` from an `IPosition`.
-	 */
-	public static lift(pos: IPosition): Position {
-		return new Position(pos.lineNumber, pos.column);
-	}
-
-	/**
-	 * Test if `obj` is an `IPosition`.
-	 */
-	public static isIPosition(obj: any): obj is IPosition {
-		return (
-			obj
-			&& (typeof obj.lineNumber === 'number')
-			&& (typeof obj.column === 'number')
-		);
-	}
-
-	public toJSON(): IPosition {
-		return {
-			lineNumber: this.lineNumber,
-			column: this.column
-		};
-	}
-}