@vscode/chat-lib 0.0.1

package/src/_internal/platform/editing/common/abstractText.ts

@@ -0,0 +1,177 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Lazy } from '../../../util/vs/base/common/lazy';
+import { Position as CorePos } from '../../../util/vs/editor/common/core/position';
+import { OffsetRange } from '../../../util/vs/editor/common/core/ranges/offsetRange';
+import { PositionOffsetTransformer } from '../../../util/vs/editor/common/core/text/positionToOffset';
+import { Range, Position as VSCodePos } from '../../../util/common/test/shims/vscodeTypesShim';
+import { TextDocumentSnapshot } from './textDocumentSnapshot';
+
+/**
+ * Represents an immutable view of a string with line/column characteristics.
+ * Offers many methods to work with various data types (ranges, positions, offsets, ...).
+*/
+export abstract class AbstractDocument {
+	abstract getText(): string;
+
+	abstract getTextInOffsetRange(offsetRange: OffsetRange): string;
+
+	abstract getPositionAtOffset(offset: number): VSCodePos;
+
+	abstract getOffsetAtPosition(position: VSCodePos): number;
+
+	abstract getLineText(lineIndex: number): string;
+
+	abstract getLineLength(lineIndex: number): number;
+
+	abstract getLineCount(): number;
+
+	rangeToOffsetRange(range: Range): OffsetRange {
+		return new OffsetRange(this.getOffsetAtPosition(range.start), this.getOffsetAtPosition(range.end));
+	}
+
+	offsetRangeToRange(offsetRange: OffsetRange): Range {
+		return new Range(
+			this.getPositionAtOffset(offsetRange.start),
+			this.getPositionAtOffset(offsetRange.endExclusive),
+		);
+	}
+
+	abstract getPositionOffsetTransformer(): PositionOffsetTransformer;
+
+	get length() {
+		return this.getText().length;
+	}
+}
+
+export interface AbstractDocumentWithLanguageId extends AbstractDocument {
+	readonly languageId: string;
+}
+
+export class VsCodeTextDocument extends AbstractDocument implements AbstractDocumentWithLanguageId {
+	public readonly uri = this.document.uri;
+
+	public readonly languageId = this.document.languageId;
+
+	constructor(public readonly document: TextDocumentSnapshot) {
+		super();
+	}
+
+	getLineText(lineIndex: number): string {
+		return this.document.lineAt(lineIndex).text;
+	}
+
+	getLineLength(lineIndex: number): number {
+		return this.document.lineAt(lineIndex).text.length;
+	}
+
+	getLineCount(): number {
+		return this.document.lineCount;
+	}
+
+	getText(): string {
+		return this.document.getText();
+	}
+
+	getTextInOffsetRange(offsetRange: OffsetRange): string {
+		return offsetRange.substring(this.document.getText());
+	}
+
+	getPositionAtOffset(offset: number): VSCodePos {
+		return this.document.positionAt(offset);
+	}
+
+	getOffsetAtPosition(position: VSCodePos): number {
+		return this.document.offsetAt(position);
+	}
+
+	private readonly _transformer = new Lazy(() => new PositionOffsetTransformer(this.document.getText()));
+
+	override getPositionOffsetTransformer() {
+		return this._transformer.value;
+	}
+}
+
+export class StringTextDocument extends AbstractDocument {
+	private readonly _transformer = new PositionOffsetTransformer(this.value);
+
+	constructor(
+		public readonly value: string,
+	) {
+		super();
+	}
+
+	override getText(): string {
+		return this.value;
+	}
+
+	getLineText(lineIndex: number): string {
+		const startOffset = this._transformer.getOffset(new CorePos(lineIndex + 1, 1));
+		const endOffset = startOffset + this.getLineLength(lineIndex);
+		return this.value.substring(startOffset, endOffset);
+	}
+
+	getLineLength(lineIndex: number): number {
+		return this._transformer.getLineLength(lineIndex + 1);
+	}
+
+	getLineCount(): number {
+		return this._transformer.textLength.lineCount + 1;
+	}
+
+	override getTextInOffsetRange(offsetRange: OffsetRange): string {
+		return offsetRange.substring(this.value);
+	}
+
+	override getPositionAtOffset(offset: number): VSCodePos {
+		return corePositionToVSCodePosition(this._transformer.getPosition(offset));
+	}
+
+	override getOffsetAtPosition(position: VSCodePos): number {
+		position = this._validatePosition(position);
+		return this._transformer.getOffset(vsCodePositionToCorePosition(position));
+	}
+
+	private _validatePosition(position: VSCodePos): VSCodePos {
+		if (position.line < 0) {
+			return new VSCodePos(0, 0);
+		}
+		const lineCount = this._transformer.textLength.lineCount + 1;
+		if (position.line >= lineCount) {
+			const lineLength = this._transformer.getLineLength(lineCount);
+			return new VSCodePos(lineCount - 1, lineLength);
+		}
+		if (position.character < 0) {
+			return new VSCodePos(position.line, 0);
+		}
+		const lineLength = this._transformer.getLineLength(position.line + 1);
+		if (position.character > lineLength) {
+			return new VSCodePos(position.line, lineLength);
+		}
+		return position;
+	}
+
+	override getPositionOffsetTransformer() {
+		return this._transformer;
+	}
+}
+
+export class StringTextDocumentWithLanguageId extends StringTextDocument implements AbstractDocumentWithLanguageId {
+	constructor(
+		value: string,
+		public readonly languageId: string,
+	) {
+		super(value);
+	}
+}
+
+function corePositionToVSCodePosition(position: CorePos): VSCodePos {
+	return new VSCodePos(position.lineNumber - 1, position.column - 1);
+}
+
+function vsCodePositionToCorePosition(position: VSCodePos): CorePos {
+	return new CorePos(position.line + 1, position.character + 1);
+}

package/src/_internal/platform/editing/common/notebookDocumentSnapshot.ts

@@ -0,0 +1,122 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { NotebookDocument, TextLine, Uri } from 'vscode';
+import { Position, Range, Selection } from '../../../util/common/test/shims/vscodeTypesShim';
+import { AlternativeNotebookDocument } from '../../notebook/common/alternativeNotebookDocument';
+import { isUriComponents, UriComponents } from '../../../util/vs/base/common/uri';
+import { getAlternativeNotebookDocumentProvider } from '../../notebook/common/alternativeContent';
+import { isNumber, isString } from '../../../util/vs/base/common/types';
+import { getDefaultLanguage } from '../../notebook/common/helpers';
+
+export interface INotebookDocumentSnapshotJSON {
+	readonly type: 'notebook';
+	readonly uri: UriComponents;
+	readonly _text: string;
+	readonly languageId: string;
+	readonly version: number;
+	readonly alternativeFormat: 'json' | 'xml' | 'text';
+}
+
+export function isNotebookDocumentSnapshotJSON(thing: any): thing is INotebookDocumentSnapshotJSON {
+	if (!thing || typeof thing !== 'object') {
+		return false;
+	}
+	return thing.type === 'notebook' && isUriComponents(thing.uri) && isString(thing._text) &&
+		isString(thing.languageId) && isNumber(thing.version) && isString(thing.alternativeFormat);
+}
+
+export class NotebookDocumentSnapshot {
+	static create(doc: NotebookDocument, format: 'json' | 'xml' | 'text'): NotebookDocumentSnapshot {
+		const uri = doc.uri;
+		const version = doc.version;
+		return new NotebookDocumentSnapshot(doc, uri, version, format);
+	}
+	static fromJSON(doc: NotebookDocument, json: INotebookDocumentSnapshotJSON): NotebookDocumentSnapshot {
+		// TODO@DonJayamanne
+		return NotebookDocumentSnapshot.create(doc, json.alternativeFormat);
+	}
+
+	readonly type = 'notebook';
+	readonly document: NotebookDocument;
+	readonly _text: string;
+	readonly uri: Uri;
+	readonly version: number;
+	readonly languageId: string;
+
+	private _alternativeDocument: AlternativeNotebookDocument;
+
+
+	private constructor(doc: NotebookDocument, uri: Uri, version: number, public readonly alternativeFormat: 'json' | 'xml' | 'text') {
+		this.document = doc;
+		this.uri = uri;
+		this.version = version;
+		this.languageId = alternativeFormat === 'text' ? getDefaultLanguage(doc) || 'python' : alternativeFormat;
+
+		this._alternativeDocument = getAlternativeNotebookDocumentProvider(alternativeFormat).getAlternativeDocument(doc);
+		this._text = this._alternativeDocument.getText();
+	}
+
+	getText(range?: Range): string {
+		return this._alternativeDocument.getText(range);
+	}
+
+	getSelection() {
+		return new Selection(0, 0, this.lineCount, 0);
+	}
+
+	getWholeRange(): Range {
+		return new Range(0, 0, this.lineCount, 0);
+	}
+
+	get lines(): string[] {
+		return this._alternativeDocument.lines;
+	}
+
+	get lineCount(): number {
+		return this._alternativeDocument.lineCount;
+	}
+
+	lineAt(line: number): TextLine;
+	lineAt(position: Position): TextLine;
+	lineAt(lineOrPosition: number | Position): TextLine {
+		let line: number | undefined;
+		if (lineOrPosition instanceof Position) {
+			line = lineOrPosition.line;
+		} else if (typeof lineOrPosition === 'number') {
+			line = lineOrPosition;
+		} else {
+			throw new Error(`Invalid argument`);
+		}
+		if (line < 0 || line >= this.lines.length) {
+			throw new Error('Illegal value for `line`');
+		}
+
+		return this._alternativeDocument.lineAt(line);
+	}
+	offsetAt(position: Position): number {
+		return this._alternativeDocument.offsetAt(position);
+	}
+	positionAt(offset: number): Position {
+		return this._alternativeDocument.positionAt(offset);
+	}
+	validateRange(range: Range): Range {
+		return this._alternativeDocument.validateRange(range);
+	}
+
+	validatePosition(position: Position): Position {
+		return this._alternativeDocument.validatePosition(position);
+	}
+	toJSON(): INotebookDocumentSnapshotJSON {
+		return {
+			type: 'notebook',
+			uri: this.uri.toJSON(),
+			languageId: this.languageId,
+			version: this.version,
+			_text: this._alternativeDocument.getText(),
+			alternativeFormat: this.alternativeFormat
+		};
+	}
+}

package/src/_internal/platform/editing/common/positionOffsetTransformer.ts

@@ -0,0 +1,202 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type * as vscode from 'vscode';
+import { splitLines } from '../../../util/vs/base/common/strings';
+import { StringEdit, StringReplacement } from '../../../util/vs/editor/common/core/edits/stringEdit';
+import { OffsetRange } from '../../../util/vs/editor/common/core/ranges/offsetRange';
+import { PrefixSumComputer } from '../../../util/vs/editor/common/model/prefixSumComputer';
+import { Position, Range, TextEdit } from '../../../util/common/test/shims/vscodeTypesShim';
+export class PositionOffsetTransformer {
+	private readonly _eol: string;
+	private _lines: string[];
+	private _lineStarts: PrefixSumComputer;
+
+	constructor(text: string) {
+		this._lines = splitLines(text);
+		this._eol = text.charAt(this._lines[0].length) === '\r' ? '\r\n' : '\n';
+		const lineStartValues = new Uint32Array(this._lines.length);
+		for (let i = 0; i < this._lines.length; i++) {
+			lineStartValues[i] = this._lines[i].length + this._eol.length;
+		}
+		this._lineStarts = new PrefixSumComputer(lineStartValues);
+	}
+
+	getText(): string {
+		return this._lines.join(this._eol);
+	}
+
+	applyOffsetEdits(offsetEdits: StringEdit) {
+		const { replacements } = offsetEdits;
+		for (let i = replacements.length - 1; i >= 0; i--) {
+			const edit = replacements[i];
+			const range = this.toRange(edit.replaceRange);
+
+			this._acceptDeleteRange(range);
+			this._acceptInsertText(range.start, edit.newText);
+		}
+	}
+
+	private _acceptDeleteRange(range: vscode.Range): void {
+
+		if (range.start.line === range.end.line) {
+			if (range.start.character === range.end.character) {
+				// Nothing to delete
+				return;
+			}
+			// Delete text on the affected line
+			this._setLineText(range.start.line,
+				this._lines[range.start.line].substring(0, range.start.character)
+				+ this._lines[range.start.line].substring(range.end.character)
+			);
+			return;
+		}
+
+		// Take remaining text on last line and append it to remaining text on first line
+		this._setLineText(range.start.line,
+			this._lines[range.start.line].substring(0, range.start.character)
+			+ this._lines[range.end.line].substring(range.end.character)
+		);
+
+		// Delete middle lines
+		this._lines.splice(range.start.line + 1, range.end.line - range.start.line);
+		this._lineStarts.removeValues(range.start.line + 1, range.end.line - range.start.line);
+	}
+
+	private _acceptInsertText(position: vscode.Position, insertText: string): void {
+		if (insertText.length === 0) {
+			// Nothing to insert
+			return;
+		}
+		const insertLines = splitLines(insertText);
+		if (insertLines.length === 1) {
+			// Inserting text on one line
+			this._setLineText(position.line,
+				this._lines[position.line].substring(0, position.character)
+				+ insertLines[0]
+				+ this._lines[position.line].substring(position.character)
+			);
+			return;
+		}
+
+		// Append overflowing text from first line to the end of text to insert
+		insertLines[insertLines.length - 1] += this._lines[position.line].substring(position.character);
+
+		// Delete overflowing text from first line and insert text on first line
+		this._setLineText(position.line,
+			this._lines[position.line].substring(0, position.character)
+			+ insertLines[0]
+		);
+
+		// Insert new lines & store lengths
+		const newLengths = new Uint32Array(insertLines.length - 1);
+		for (let i = 1; i < insertLines.length; i++) {
+			this._lines.splice(position.line + 1 + i - 1, 0, insertLines[i]);
+			newLengths[i - 1] = insertLines[i].length + this._eol.length;
+		}
+
+		this._lineStarts.insertValues(position.line + 1, newLengths);
+	}
+
+	/**
+	 * All changes to a line's text go through this method
+	 */
+	private _setLineText(lineIndex: number, newValue: string): void {
+		this._lines[lineIndex] = newValue;
+		this._lineStarts.setValue(lineIndex, this._lines[lineIndex].length + this._eol.length);
+	}
+
+	getLineCount(): number {
+		return this._lines.length;
+	}
+
+	getOffset(position: Position): number {
+		position = this.validatePosition(position);
+		return this._lineStarts.getPrefixSum(position.line - 1) + position.character;
+	}
+
+	getPosition(offset: number): Position {
+		offset = Math.floor(offset);
+		offset = Math.max(0, offset);
+
+		const out = this._lineStarts.getIndexOf(offset);
+
+		const lineLength = this._lines[out.index].length;
+
+		// Ensure we return a valid position
+		return new Position(out.index, Math.min(out.remainder, lineLength));
+	}
+
+	toRange(offsetRange: OffsetRange): Range {
+		return new Range(this.getPosition(offsetRange.start), this.getPosition(offsetRange.endExclusive));
+	}
+
+	toOffsetRange(range: Range): OffsetRange {
+		return new OffsetRange(
+			this.getOffset(range.start),
+			this.getOffset(range.end)
+		);
+	}
+
+	toOffsetEdit(edits: readonly TextEdit[]): StringEdit {
+		const validEdits = edits.map(edit => new TextEdit(this.validateRange(edit.range), edit.newText));
+		return new StringEdit(validEdits.map(edit => {
+			return new StringReplacement(this.toOffsetRange(edit.range), edit.newText);
+		}));
+	}
+
+	toTextEdits(edit: StringEdit): TextEdit[] {
+		return edit.replacements.map(edit => {
+			return new TextEdit(this.toRange(edit.replaceRange), edit.newText);
+		});
+	}
+
+	public validatePosition(position: vscode.Position): vscode.Position {
+		if (!(position instanceof Position)) {
+			throw new Error('Invalid argument');
+		}
+
+		if (this._lines.length === 0) {
+			return position.with(0, 0);
+		}
+
+		let { line, character } = position;
+		let hasChanged = false;
+
+		if (line < 0) {
+			line = 0;
+			character = 0;
+			hasChanged = true;
+		}
+		else if (line >= this._lines.length) {
+			line = this._lines.length - 1;
+			character = this._lines[line].length;
+			hasChanged = true;
+		}
+		else {
+			const maxCharacter = this._lines[line].length;
+			if (character < 0) {
+				character = 0;
+				hasChanged = true;
+			}
+			else if (character > maxCharacter) {
+				character = maxCharacter;
+				hasChanged = true;
+			}
+		}
+
+		if (!hasChanged) {
+			return position;
+		}
+		return new Position(line, character);
+	}
+
+	validateRange(range: Range): Range {
+		return new Range(
+			this.validatePosition(range.start),
+			this.validatePosition(range.end)
+		);
+	}
+}