@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/editor/common/core/text/abstractText.ts

@@ -1,127 +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 { assert } from '../../../../base/common/assert';
-import { splitLines } from '../../../../base/common/strings';
-import { Position } from '../position';
-import { PositionOffsetTransformer } from './positionToOffsetImpl';
-import { Range } from '../range';
-import { LineRange } from '../ranges/lineRange';
-import { TextLength } from './textLength';
-import { OffsetRange } from '../ranges/offsetRange';
-
-export abstract class AbstractText {
-	abstract getValueOfRange(range: Range): string;
-	abstract readonly length: TextLength;
-
-	get endPositionExclusive(): Position {
-		return this.length.addToPosition(new Position(1, 1));
-	}
-
-	get lineRange(): LineRange {
-		return this.length.toLineRange();
-	}
-
-	getValue(): string {
-		return this.getValueOfRange(this.length.toRange());
-	}
-
-	getValueOfOffsetRange(range: OffsetRange): string {
-		return this.getValueOfRange(this.getTransformer().getRange(range));
-	}
-
-	getLineLength(lineNumber: number): number {
-		return this.getValueOfRange(new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER)).length;
-	}
-
-	private _transformer: PositionOffsetTransformer | undefined = undefined;
-
-	getTransformer(): PositionOffsetTransformer {
-		if (!this._transformer) {
-			this._transformer = new PositionOffsetTransformer(this.getValue());
-		}
-		return this._transformer;
-	}
-
-	getLineAt(lineNumber: number): string {
-		return this.getValueOfRange(new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER));
-	}
-
-	getLines(): string[] {
-		const value = this.getValue();
-		return splitLines(value);
-	}
-
-	getLinesOfRange(range: LineRange): string[] {
-		return range.mapToLineArray(lineNumber => this.getLineAt(lineNumber));
-	}
-
-	equals(other: AbstractText): boolean {
-		if (this === other) {
-			return true;
-		}
-		return this.getValue() === other.getValue();
-	}
-}
-
-export class LineBasedText extends AbstractText {
-	constructor(
-		private readonly _getLineContent: (lineNumber: number) => string,
-		private readonly _lineCount: number
-	) {
-		assert(_lineCount >= 1);
-
-		super();
-	}
-
-	override getValueOfRange(range: Range): string {
-		if (range.startLineNumber === range.endLineNumber) {
-			return this._getLineContent(range.startLineNumber).substring(range.startColumn - 1, range.endColumn - 1);
-		}
-		let result = this._getLineContent(range.startLineNumber).substring(range.startColumn - 1);
-		for (let i = range.startLineNumber + 1; i < range.endLineNumber; i++) {
-			result += '\n' + this._getLineContent(i);
-		}
-		result += '\n' + this._getLineContent(range.endLineNumber).substring(0, range.endColumn - 1);
-		return result;
-	}
-
-	override getLineLength(lineNumber: number): number {
-		return this._getLineContent(lineNumber).length;
-	}
-
-	get length(): TextLength {
-		const lastLine = this._getLineContent(this._lineCount);
-		return new TextLength(this._lineCount - 1, lastLine.length);
-	}
-}
-
-export class ArrayText extends LineBasedText {
-	constructor(lines: string[]) {
-		super(
-			lineNumber => lines[lineNumber - 1],
-			lines.length
-		);
-	}
-}
-
-export class StringText extends AbstractText {
-	private readonly _t;
-
-	constructor(public readonly value: string) {
-		super();
-		this._t = new PositionOffsetTransformer(this.value);
-	}
-
-	getValueOfRange(range: Range): string {
-		return this._t.getOffsetRange(range).substring(this.value);
-	}
-
-	get length(): TextLength {
-		return this._t.textLength;
-	}
-}

package/src/_internal/util/vs/editor/common/core/text/positionToOffset.ts

@@ -1,26 +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 { StringEdit, StringReplacement } from '../edits/stringEdit';
-import { TextEdit, TextReplacement } from '../edits/textEdit';
-import { _setPositionOffsetTransformerDependencies } from './positionToOffsetImpl';
-import { TextLength } from './textLength';
-
-export { PositionOffsetTransformerBase, PositionOffsetTransformer } from './positionToOffsetImpl';
-
-_setPositionOffsetTransformerDependencies({
-	StringEdit: StringEdit,
-	StringReplacement: StringReplacement,
-	TextReplacement: TextReplacement,
-	TextEdit: TextEdit,
-	TextLength: TextLength,
-});
-
-// TODO@hediet this is dept and needs to go. See https://github.com/microsoft/vscode/issues/251126.
-export function ensureDependenciesAreSet(): void {
-	// Noop
-}

package/src/_internal/util/vs/editor/common/core/text/positionToOffsetImpl.ts

@@ -1,144 +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 { findLastIdxMonotonous } from '../../../../base/common/arraysFind';
-import { StringEdit, StringReplacement } from '../edits/stringEdit';
-import { OffsetRange } from '../ranges/offsetRange';
-import { Position } from '../position';
-import { Range } from '../range';
-import type { TextReplacement, TextEdit } from '../edits/textEdit';
-import type { TextLength } from './textLength';
-
-export abstract class PositionOffsetTransformerBase {
-	abstract getOffset(position: Position): number;
-
-	getOffsetRange(range: Range): OffsetRange {
-		return new OffsetRange(
-			this.getOffset(range.getStartPosition()),
-			this.getOffset(range.getEndPosition())
-		);
-	}
-
-	abstract getPosition(offset: number): Position;
-
-	getRange(offsetRange: OffsetRange): Range {
-		return Range.fromPositions(
-			this.getPosition(offsetRange.start),
-			this.getPosition(offsetRange.endExclusive)
-		);
-	}
-
-	getStringEdit(edit: TextEdit): StringEdit {
-		const edits = edit.replacements.map(e => this.getStringReplacement(e));
-		return new Deps.deps.StringEdit(edits);
-	}
-
-	getStringReplacement(edit: TextReplacement): StringReplacement {
-		return new Deps.deps.StringReplacement(this.getOffsetRange(edit.range), edit.text);
-	}
-
-	getTextReplacement(edit: StringReplacement): TextReplacement {
-		return new Deps.deps.TextReplacement(this.getRange(edit.replaceRange), edit.newText);
-	}
-
-	getTextEdit(edit: StringEdit): TextEdit {
-		const edits = edit.replacements.map(e => this.getTextReplacement(e));
-		return new Deps.deps.TextEdit(edits);
-	}
-}
-
-interface IDeps {
-	StringEdit: typeof StringEdit;
-	StringReplacement: typeof StringReplacement;
-	TextReplacement: typeof TextReplacement;
-	TextEdit: typeof TextEdit;
-	TextLength: typeof TextLength;
-}
-
-class Deps {
-	static _deps: IDeps | undefined = undefined;
-	static get deps(): IDeps {
-		if (!this._deps) {
-			throw new Error('Dependencies not set. Call _setDependencies first.');
-		}
-		return this._deps;
-	}
-}
-
-/** This is to break circular module dependencies. */
-export function _setPositionOffsetTransformerDependencies(deps: IDeps): void {
-	Deps._deps = deps;
-}
-
-export class PositionOffsetTransformer extends PositionOffsetTransformerBase {
-	private readonly lineStartOffsetByLineIdx: number[];
-	private readonly lineEndOffsetByLineIdx: number[];
-
-	constructor(public readonly text: string) {
-		super();
-
-		this.lineStartOffsetByLineIdx = [];
-		this.lineEndOffsetByLineIdx = [];
-
-		this.lineStartOffsetByLineIdx.push(0);
-		for (let i = 0; i < text.length; i++) {
-			if (text.charAt(i) === '\n') {
-				this.lineStartOffsetByLineIdx.push(i + 1);
-				if (i > 0 && text.charAt(i - 1) === '\r') {
-					this.lineEndOffsetByLineIdx.push(i - 1);
-				} else {
-					this.lineEndOffsetByLineIdx.push(i);
-				}
-			}
-		}
-		this.lineEndOffsetByLineIdx.push(text.length);
-	}
-
-	override getOffset(position: Position): number {
-		const valPos = this._validatePosition(position);
-		return this.lineStartOffsetByLineIdx[valPos.lineNumber - 1] + valPos.column - 1;
-	}
-
-	private _validatePosition(position: Position): Position {
-		if (position.lineNumber < 1) {
-			return new Position(1, 1);
-		}
-		const lineCount = this.textLength.lineCount + 1;
-		if (position.lineNumber > lineCount) {
-			const lineLength = this.getLineLength(lineCount);
-			return new Position(lineCount, lineLength + 1);
-		}
-		if (position.column < 1) {
-			return new Position(position.lineNumber, 1);
-		}
-		const lineLength = this.getLineLength(position.lineNumber);
-		if (position.column - 1 > lineLength) {
-			return new Position(position.lineNumber, lineLength + 1);
-		}
-		return position;
-	}
-
-	override getPosition(offset: number): Position {
-		const idx = findLastIdxMonotonous(this.lineStartOffsetByLineIdx, i => i <= offset);
-		const lineNumber = idx + 1;
-		const column = offset - this.lineStartOffsetByLineIdx[idx] + 1;
-		return new Position(lineNumber, column);
-	}
-
-	getTextLength(offsetRange: OffsetRange): TextLength {
-		return Deps.deps.TextLength.ofRange(this.getRange(offsetRange));
-	}
-
-	get textLength(): TextLength {
-		const lineIdx = this.lineStartOffsetByLineIdx.length - 1;
-		return new Deps.deps.TextLength(lineIdx, this.text.length - this.lineStartOffsetByLineIdx[lineIdx]);
-	}
-
-	getLineLength(lineNumber: number): number {
-		return this.lineEndOffsetByLineIdx[lineNumber - 1] - this.lineStartOffsetByLineIdx[lineNumber - 1];
-	}
-}

package/src/_internal/util/vs/editor/common/core/text/textLength.ts

@@ -1,150 +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 { LineRange } from '../ranges/lineRange';
-import { Position } from '../position';
-import { Range } from '../range';
-import { OffsetRange } from '../ranges/offsetRange';
-
-/**
- * Represents a non-negative length of text in terms of line and column count.
-*/
-export class TextLength {
-	public static zero = new TextLength(0, 0);
-
-	public static lengthDiffNonNegative(start: TextLength, end: TextLength): TextLength {
-		if (end.isLessThan(start)) {
-			return TextLength.zero;
-		}
-		if (start.lineCount === end.lineCount) {
-			return new TextLength(0, end.columnCount - start.columnCount);
-		} else {
-			return new TextLength(end.lineCount - start.lineCount, end.columnCount);
-		}
-	}
-
-	public static betweenPositions(position1: Position, position2: Position): TextLength {
-		if (position1.lineNumber === position2.lineNumber) {
-			return new TextLength(0, position2.column - position1.column);
-		} else {
-			return new TextLength(position2.lineNumber - position1.lineNumber, position2.column - 1);
-		}
-	}
-
-	public static fromPosition(pos: Position): TextLength {
-		return new TextLength(pos.lineNumber - 1, pos.column - 1);
-	}
-
-	public static ofRange(range: Range) {
-		return TextLength.betweenPositions(range.getStartPosition(), range.getEndPosition());
-	}
-
-	public static ofText(text: string): TextLength {
-		let line = 0;
-		let column = 0;
-		for (const c of text) {
-			if (c === '\n') {
-				line++;
-				column = 0;
-			} else {
-				column++;
-			}
-		}
-		return new TextLength(line, column);
-	}
-
-	public static ofSubstr(str: string, range: OffsetRange): TextLength {
-		return TextLength.ofText(range.substring(str));
-	}
-
-	public static sum<T>(fragments: readonly T[], getLength: (f: T) => TextLength): TextLength {
-		return fragments.reduce((acc, f) => acc.add(getLength(f)), TextLength.zero);
-	}
-
-	constructor(
-		public readonly lineCount: number,
-		public readonly columnCount: number
-	) { }
-
-	public isZero() {
-		return this.lineCount === 0 && this.columnCount === 0;
-	}
-
-	public isLessThan(other: TextLength): boolean {
-		if (this.lineCount !== other.lineCount) {
-			return this.lineCount < other.lineCount;
-		}
-		return this.columnCount < other.columnCount;
-	}
-
-	public isGreaterThan(other: TextLength): boolean {
-		if (this.lineCount !== other.lineCount) {
-			return this.lineCount > other.lineCount;
-		}
-		return this.columnCount > other.columnCount;
-	}
-
-	public isGreaterThanOrEqualTo(other: TextLength): boolean {
-		if (this.lineCount !== other.lineCount) {
-			return this.lineCount > other.lineCount;
-		}
-		return this.columnCount >= other.columnCount;
-	}
-
-	public equals(other: TextLength): boolean {
-		return this.lineCount === other.lineCount && this.columnCount === other.columnCount;
-	}
-
-	public compare(other: TextLength): number {
-		if (this.lineCount !== other.lineCount) {
-			return this.lineCount - other.lineCount;
-		}
-		return this.columnCount - other.columnCount;
-	}
-
-	public add(other: TextLength): TextLength {
-		if (other.lineCount === 0) {
-			return new TextLength(this.lineCount, this.columnCount + other.columnCount);
-		} else {
-			return new TextLength(this.lineCount + other.lineCount, other.columnCount);
-		}
-	}
-
-	public createRange(startPosition: Position): Range {
-		if (this.lineCount === 0) {
-			return new Range(startPosition.lineNumber, startPosition.column, startPosition.lineNumber, startPosition.column + this.columnCount);
-		} else {
-			return new Range(startPosition.lineNumber, startPosition.column, startPosition.lineNumber + this.lineCount, this.columnCount + 1);
-		}
-	}
-
-	public toRange(): Range {
-		return new Range(1, 1, this.lineCount + 1, this.columnCount + 1);
-	}
-
-	public toLineRange(): LineRange {
-		return LineRange.ofLength(1, this.lineCount + 1);
-	}
-
-	public addToPosition(position: Position): Position {
-		if (this.lineCount === 0) {
-			return new Position(position.lineNumber, position.column + this.columnCount);
-		} else {
-			return new Position(position.lineNumber + this.lineCount, this.columnCount + 1);
-		}
-	}
-
-	public addToRange(range: Range): Range {
-		return Range.fromPositions(
-			this.addToPosition(range.getStartPosition()),
-			this.addToPosition(range.getEndPosition())
-		);
-	}
-
-	toString() {
-		return `${this.lineCount},${this.columnCount}`;
-	}
-}

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

@@ -1,177 +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 { Iterable } from '../../../base/common/iterator';
-import { toDisposable } from '../../../base/common/lifecycle';
-import { LinkedList } from '../../../base/common/linkedList';
-
-export const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?';
-
-/**
- * Word inside a model.
- */
-export interface IWordAtPosition {
-	/**
-	 * The word.
-	 */
-	readonly word: string;
-	/**
-	 * The column where the word starts.
-	 */
-	readonly startColumn: number;
-	/**
-	 * The column where the word ends.
-	 */
-	readonly endColumn: number;
-}
-
-/**
- * Create a word definition regular expression based on default word separators.
- * Optionally provide allowed separators that should be included in words.
- *
- * The default would look like this:
- * /(-?\d*\.\d\w*)|([^\`\~\!\@\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g
- */
-function createWordRegExp(allowInWords: string = ''): RegExp {
-	let source = '(-?\\d*\\.\\d\\w*)|([^';
-	for (const sep of USUAL_WORD_SEPARATORS) {
-		if (allowInWords.indexOf(sep) >= 0) {
-			continue;
-		}
-		source += '\\' + sep;
-	}
-	source += '\\s]+)';
-	return new RegExp(source, 'g');
-}
-
-// catches numbers (including floating numbers) in the first group, and alphanum in the second
-export const DEFAULT_WORD_REGEXP = createWordRegExp();
-
-export function ensureValidWordDefinition(wordDefinition?: RegExp | null): RegExp {
-	let result: RegExp = DEFAULT_WORD_REGEXP;
-
-	if (wordDefinition && (wordDefinition instanceof RegExp)) {
-		if (!wordDefinition.global) {
-			let flags = 'g';
-			if (wordDefinition.ignoreCase) {
-				flags += 'i';
-			}
-			if (wordDefinition.multiline) {
-				flags += 'm';
-			}
-			if (wordDefinition.unicode) {
-				flags += 'u';
-			}
-			result = new RegExp(wordDefinition.source, flags);
-		} else {
-			result = wordDefinition;
-		}
-	}
-
-	result.lastIndex = 0;
-
-	return result;
-}
-
-
-export interface IGetWordAtTextConfig {
-	maxLen: number;
-	windowSize: number;
-	timeBudget: number;
-}
-
-
-const _defaultConfig = new LinkedList<IGetWordAtTextConfig>();
-_defaultConfig.unshift({
-	maxLen: 1000,
-	windowSize: 15,
-	timeBudget: 150
-});
-
-export function setDefaultGetWordAtTextConfig(value: IGetWordAtTextConfig) {
-	const rm = _defaultConfig.unshift(value);
-	return toDisposable(rm);
-}
-
-export function getWordAtText(column: number, wordDefinition: RegExp, text: string, textOffset: number, config?: IGetWordAtTextConfig): IWordAtPosition | null {
-	// Ensure the regex has the 'g' flag, otherwise this will loop forever
-	wordDefinition = ensureValidWordDefinition(wordDefinition);
-
-	if (!config) {
-		config = Iterable.first(_defaultConfig)!;
-	}
-
-	if (text.length > config.maxLen) {
-		// don't throw strings that long at the regexp
-		// but use a sub-string in which a word must occur
-		let start = column - config.maxLen / 2;
-		if (start < 0) {
-			start = 0;
-		} else {
-			textOffset += start;
-		}
-		text = text.substring(start, column + config.maxLen / 2);
-		return getWordAtText(column, wordDefinition, text, textOffset, config);
-	}
-
-	const t1 = Date.now();
-	const pos = column - 1 - textOffset;
-
-	let prevRegexIndex = -1;
-	let match: RegExpExecArray | null = null;
-
-	for (let i = 1; ; i++) {
-		// check time budget
-		if (Date.now() - t1 >= config.timeBudget) {
-			break;
-		}
-
-		// reset the index at which the regexp should start matching, also know where it
-		// should stop so that subsequent search don't repeat previous searches
-		const regexIndex = pos - config.windowSize * i;
-		wordDefinition.lastIndex = Math.max(0, regexIndex);
-		const thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex);
-
-		if (!thisMatch && match) {
-			// stop: we have something
-			break;
-		}
-
-		match = thisMatch;
-
-		// stop: searched at start
-		if (regexIndex <= 0) {
-			break;
-		}
-		prevRegexIndex = regexIndex;
-	}
-
-	if (match) {
-		const result = {
-			word: match[0],
-			startColumn: textOffset + 1 + match.index,
-			endColumn: textOffset + 1 + match.index + match[0].length
-		};
-		wordDefinition.lastIndex = 0;
-		return result;
-	}
-
-	return null;
-}
-
-function _findRegexMatchEnclosingPosition(wordDefinition: RegExp, text: string, pos: number, stopPos: number): RegExpExecArray | null {
-	let match: RegExpExecArray | null;
-	while (match = wordDefinition.exec(text)) {
-		const matchIndex = match.index || 0;
-		if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {
-			return match;
-		} else if (stopPos > 0 && matchIndex > stopPos) {
-			return null;
-		}
-	}
-	return null;
-}