@vscode/chat-lib 0.0.1

package/src/_internal/util/vs/workbench/api/common/extHostTypes/position.ts

@@ -0,0 +1,195 @@
+//!!! 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 type * as vscode from 'vscode';
+import { illegalArgument } from '../../../../base/common/errors';
+import { es5ClassCompat } from './es5ClassCompat';
+
+@es5ClassCompat
+export class Position {
+
+	static Min(...positions: Position[]): Position {
+		if (positions.length === 0) {
+			throw new TypeError();
+		}
+		let result = positions[0];
+		for (let i = 1; i < positions.length; i++) {
+			const p = positions[i];
+			if (p.isBefore(result)) {
+				result = p;
+			}
+		}
+		return result;
+	}
+
+	static Max(...positions: Position[]): Position {
+		if (positions.length === 0) {
+			throw new TypeError();
+		}
+		let result = positions[0];
+		for (let i = 1; i < positions.length; i++) {
+			const p = positions[i];
+			if (p.isAfter(result)) {
+				result = p;
+			}
+		}
+		return result;
+	}
+
+	static isPosition(other: any): other is Position {
+		if (!other) {
+			return false;
+		}
+		if (other instanceof Position) {
+			return true;
+		}
+		const { line, character } = <Position>other;
+		if (typeof line === 'number' && typeof character === 'number') {
+			return true;
+		}
+		return false;
+	}
+
+	static of(obj: vscode.Position): Position {
+		if (obj instanceof Position) {
+			return obj;
+		} else if (this.isPosition(obj)) {
+			return new Position(obj.line, obj.character);
+		}
+		throw new Error('Invalid argument, is NOT a position-like object');
+	}
+
+	private _line: number;
+	private _character: number;
+
+	get line(): number {
+		return this._line;
+	}
+
+	get character(): number {
+		return this._character;
+	}
+
+	constructor(line: number, character: number) {
+		if (line < 0) {
+			throw illegalArgument('line must be non-negative');
+		}
+		if (character < 0) {
+			throw illegalArgument('character must be non-negative');
+		}
+		this._line = line;
+		this._character = character;
+	}
+
+	isBefore(other: Position): boolean {
+		if (this._line < other._line) {
+			return true;
+		}
+		if (other._line < this._line) {
+			return false;
+		}
+		return this._character < other._character;
+	}
+
+	isBeforeOrEqual(other: Position): boolean {
+		if (this._line < other._line) {
+			return true;
+		}
+		if (other._line < this._line) {
+			return false;
+		}
+		return this._character <= other._character;
+	}
+
+	isAfter(other: Position): boolean {
+		return !this.isBeforeOrEqual(other);
+	}
+
+	isAfterOrEqual(other: Position): boolean {
+		return !this.isBefore(other);
+	}
+
+	isEqual(other: Position): boolean {
+		return this._line === other._line && this._character === other._character;
+	}
+
+	compareTo(other: Position): number {
+		if (this._line < other._line) {
+			return -1;
+		} else if (this._line > other.line) {
+			return 1;
+		} else {
+			// equal line
+			if (this._character < other._character) {
+				return -1;
+			} else if (this._character > other._character) {
+				return 1;
+			} else {
+				// equal line and character
+				return 0;
+			}
+		}
+	}
+
+	translate(change: { lineDelta?: number; characterDelta?: number }): Position;
+	translate(lineDelta?: number, characterDelta?: number): Position;
+	translate(lineDeltaOrChange: number | undefined | { lineDelta?: number; characterDelta?: number }, characterDelta: number = 0): Position {
+
+		if (lineDeltaOrChange === null || characterDelta === null) {
+			throw illegalArgument();
+		}
+
+		let lineDelta: number;
+		if (typeof lineDeltaOrChange === 'undefined') {
+			lineDelta = 0;
+		} else if (typeof lineDeltaOrChange === 'number') {
+			lineDelta = lineDeltaOrChange;
+		} else {
+			lineDelta = typeof lineDeltaOrChange.lineDelta === 'number' ? lineDeltaOrChange.lineDelta : 0;
+			characterDelta = typeof lineDeltaOrChange.characterDelta === 'number' ? lineDeltaOrChange.characterDelta : 0;
+		}
+
+		if (lineDelta === 0 && characterDelta === 0) {
+			return this;
+		}
+		return new Position(this.line + lineDelta, this.character + characterDelta);
+	}
+
+	with(change: { line?: number; character?: number }): Position;
+	with(line?: number, character?: number): Position;
+	with(lineOrChange: number | undefined | { line?: number; character?: number }, character: number = this.character): Position {
+
+		if (lineOrChange === null || character === null) {
+			throw illegalArgument();
+		}
+
+		let line: number;
+		if (typeof lineOrChange === 'undefined') {
+			line = this.line;
+
+		} else if (typeof lineOrChange === 'number') {
+			line = lineOrChange;
+
+		} else {
+			line = typeof lineOrChange.line === 'number' ? lineOrChange.line : this.line;
+			character = typeof lineOrChange.character === 'number' ? lineOrChange.character : this.character;
+		}
+
+		if (line === this.line && character === this.character) {
+			return this;
+		}
+		return new Position(line, character);
+	}
+
+	toJSON(): any {
+		return { line: this.line, character: this.character };
+	}
+
+	[Symbol.for('debug.description')]() {
+		return `(${this.line}:${this.character})`;
+	}
+}

package/src/_internal/util/vs/workbench/api/common/extHostTypes/range.ts

@@ -0,0 +1,167 @@
+//!!! 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 type * as vscode from 'vscode';
+import { illegalArgument } from '../../../../base/common/errors';
+import { es5ClassCompat } from './es5ClassCompat';
+import { Position } from './position';
+
+@es5ClassCompat
+export class Range {
+
+	static isRange(thing: any): thing is vscode.Range {
+		if (thing instanceof Range) {
+			return true;
+		}
+		if (!thing) {
+			return false;
+		}
+		return Position.isPosition((<Range>thing).start)
+			&& Position.isPosition((<Range>thing.end));
+	}
+
+	static of(obj: vscode.Range): Range {
+		if (obj instanceof Range) {
+			return obj;
+		}
+		if (this.isRange(obj)) {
+			return new Range(obj.start, obj.end);
+		}
+		throw new Error('Invalid argument, is NOT a range-like object');
+	}
+
+	protected _start: Position;
+	protected _end: Position;
+
+	get start(): Position {
+		return this._start;
+	}
+
+	get end(): Position {
+		return this._end;
+	}
+
+	constructor(start: vscode.Position, end: vscode.Position);
+	constructor(start: Position, end: Position);
+	constructor(startLine: number, startColumn: number, endLine: number, endColumn: number);
+	constructor(startLineOrStart: number | Position | vscode.Position, startColumnOrEnd: number | Position | vscode.Position, endLine?: number, endColumn?: number) {
+		let start: Position | undefined;
+		let end: Position | undefined;
+
+		if (typeof startLineOrStart === 'number' && typeof startColumnOrEnd === 'number' && typeof endLine === 'number' && typeof endColumn === 'number') {
+			start = new Position(startLineOrStart, startColumnOrEnd);
+			end = new Position(endLine, endColumn);
+		} else if (Position.isPosition(startLineOrStart) && Position.isPosition(startColumnOrEnd)) {
+			start = Position.of(startLineOrStart);
+			end = Position.of(startColumnOrEnd);
+		}
+
+		if (!start || !end) {
+			throw new Error('Invalid arguments');
+		}
+
+		if (start.isBefore(end)) {
+			this._start = start;
+			this._end = end;
+		} else {
+			this._start = end;
+			this._end = start;
+		}
+	}
+
+	contains(positionOrRange: Position | Range): boolean {
+		if (Range.isRange(positionOrRange)) {
+			return this.contains(positionOrRange.start)
+				&& this.contains(positionOrRange.end);
+
+		} else if (Position.isPosition(positionOrRange)) {
+			if (Position.of(positionOrRange).isBefore(this._start)) {
+				return false;
+			}
+			if (this._end.isBefore(positionOrRange)) {
+				return false;
+			}
+			return true;
+		}
+		return false;
+	}
+
+	isEqual(other: Range): boolean {
+		return this._start.isEqual(other._start) && this._end.isEqual(other._end);
+	}
+
+	intersection(other: Range): Range | undefined {
+		const start = Position.Max(other.start, this._start);
+		const end = Position.Min(other.end, this._end);
+		if (start.isAfter(end)) {
+			// this happens when there is no overlap:
+			// |-----|
+			//          |----|
+			return undefined;
+		}
+		return new Range(start, end);
+	}
+
+	union(other: Range): Range {
+		if (this.contains(other)) {
+			return this;
+		} else if (other.contains(this)) {
+			return other;
+		}
+		const start = Position.Min(other.start, this._start);
+		const end = Position.Max(other.end, this.end);
+		return new Range(start, end);
+	}
+
+	get isEmpty(): boolean {
+		return this._start.isEqual(this._end);
+	}
+
+	get isSingleLine(): boolean {
+		return this._start.line === this._end.line;
+	}
+
+	with(change: { start?: Position; end?: Position }): Range;
+	with(start?: Position, end?: Position): Range;
+	with(startOrChange: Position | undefined | { start?: Position; end?: Position }, end: Position = this.end): Range {
+
+		if (startOrChange === null || end === null) {
+			throw illegalArgument();
+		}
+
+		let start: Position;
+		if (!startOrChange) {
+			start = this.start;
+
+		} else if (Position.isPosition(startOrChange)) {
+			start = startOrChange;
+
+		} else {
+			start = startOrChange.start || this.start;
+			end = startOrChange.end || this.end;
+		}
+
+		if (start.isEqual(this._start) && end.isEqual(this.end)) {
+			return this;
+		}
+		return new Range(start, end);
+	}
+
+	toJSON(): any {
+		return [this.start, this.end];
+	}
+
+	[Symbol.for('debug.description')]() {
+		return getDebugDescriptionOfRange(this);
+	}
+}
+
+export function getDebugDescriptionOfRange(range: vscode.Range): string {
+	return range.isEmpty
+		? `[${range.start.line}:${range.start.character})`
+		: `[${range.start.line}:${range.start.character} -> ${range.end.line}:${range.end.character})`;
+}

package/src/_internal/util/vs/workbench/api/common/extHostTypes/selection.ts

@@ -0,0 +1,94 @@
+//!!! 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 type * as vscode from 'vscode';
+import { es5ClassCompat } from './es5ClassCompat';
+import { Position } from './position';
+import { getDebugDescriptionOfRange, Range } from './range';
+
+@es5ClassCompat
+export class Selection extends Range {
+
+	static isSelection(thing: any): thing is Selection {
+		if (thing instanceof Selection) {
+			return true;
+		}
+		if (!thing) {
+			return false;
+		}
+		return Range.isRange(thing)
+			&& Position.isPosition((<Selection>thing).anchor)
+			&& Position.isPosition((<Selection>thing).active)
+			&& typeof (<Selection>thing).isReversed === 'boolean';
+	}
+
+	private _anchor: Position;
+
+	public get anchor(): Position {
+		return this._anchor;
+	}
+
+	private _active: Position;
+
+	public get active(): Position {
+		return this._active;
+	}
+
+	constructor(anchor: Position, active: Position);
+	constructor(anchorLine: number, anchorColumn: number, activeLine: number, activeColumn: number);
+	constructor(anchorLineOrAnchor: number | Position, anchorColumnOrActive: number | Position, activeLine?: number, activeColumn?: number) {
+		let anchor: Position | undefined;
+		let active: Position | undefined;
+
+		if (typeof anchorLineOrAnchor === 'number' && typeof anchorColumnOrActive === 'number' && typeof activeLine === 'number' && typeof activeColumn === 'number') {
+			anchor = new Position(anchorLineOrAnchor, anchorColumnOrActive);
+			active = new Position(activeLine, activeColumn);
+		} else if (Position.isPosition(anchorLineOrAnchor) && Position.isPosition(anchorColumnOrActive)) {
+			anchor = Position.of(anchorLineOrAnchor);
+			active = Position.of(anchorColumnOrActive);
+		}
+
+		if (!anchor || !active) {
+			throw new Error('Invalid arguments');
+		}
+
+		super(anchor, active);
+
+		this._anchor = anchor;
+		this._active = active;
+	}
+
+	get isReversed(): boolean {
+		return this._anchor === this._end;
+	}
+
+	override toJSON() {
+		return {
+			start: this.start,
+			end: this.end,
+			active: this.active,
+			anchor: this.anchor
+		};
+	}
+
+
+	[Symbol.for('debug.description')]() {
+		return getDebugDescriptionOfSelection(this);
+	}
+}
+
+export function getDebugDescriptionOfSelection(selection: vscode.Selection): string {
+	let rangeStr = getDebugDescriptionOfRange(selection);
+	if (!selection.isEmpty) {
+		if (selection.active.isEqual(selection.start)) {
+			rangeStr = `|${rangeStr}`;
+		} else {
+			rangeStr = `${rangeStr}|`;
+		}
+	}
+	return rangeStr;
+}

package/src/_internal/util/vs/workbench/api/common/extHostTypes/snippetString.ts

@@ -0,0 +1,103 @@
+//!!! 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 { es5ClassCompat } from './es5ClassCompat';
+
+@es5ClassCompat
+export class SnippetString {
+
+	static isSnippetString(thing: any): thing is SnippetString {
+		if (thing instanceof SnippetString) {
+			return true;
+		}
+		if (!thing) {
+			return false;
+		}
+		return typeof (<SnippetString>thing).value === 'string';
+	}
+
+	private static _escape(value: string): string {
+		return value.replace(/\$|}|\\/g, '\\$&');
+	}
+
+	private _tabstop: number = 1;
+
+	value: string;
+
+	constructor(value?: string) {
+		this.value = value || '';
+	}
+
+	appendText(string: string): SnippetString {
+		this.value += SnippetString._escape(string);
+		return this;
+	}
+
+	appendTabstop(number: number = this._tabstop++): SnippetString {
+		this.value += '$';
+		this.value += number;
+		return this;
+	}
+
+	appendPlaceholder(value: string | ((snippet: SnippetString) => any), number: number = this._tabstop++): SnippetString {
+
+		if (typeof value === 'function') {
+			const nested = new SnippetString();
+			nested._tabstop = this._tabstop;
+			value(nested);
+			this._tabstop = nested._tabstop;
+			value = nested.value;
+		} else {
+			value = SnippetString._escape(value);
+		}
+
+		this.value += '${';
+		this.value += number;
+		this.value += ':';
+		this.value += value;
+		this.value += '}';
+
+		return this;
+	}
+
+	appendChoice(values: string[], number: number = this._tabstop++): SnippetString {
+		const value = values.map(s => s.replaceAll(/[|\\,]/g, '\\$&')).join(',');
+
+		this.value += '${';
+		this.value += number;
+		this.value += '|';
+		this.value += value;
+		this.value += '|}';
+
+		return this;
+	}
+
+	appendVariable(name: string, defaultValue?: string | ((snippet: SnippetString) => any)): SnippetString {
+
+		if (typeof defaultValue === 'function') {
+			const nested = new SnippetString();
+			nested._tabstop = this._tabstop;
+			defaultValue(nested);
+			this._tabstop = nested._tabstop;
+			defaultValue = nested.value;
+
+		} else if (typeof defaultValue === 'string') {
+			defaultValue = defaultValue.replace(/\$|}/g, '\\$&'); // CodeQL [SM02383] I do not want to escape backslashes here
+		}
+
+		this.value += '${';
+		this.value += name;
+		if (defaultValue) {
+			this.value += ':';
+			this.value += defaultValue;
+		}
+		this.value += '}';
+
+
+		return this;
+	}
+}

package/src/_internal/util/vs/workbench/api/common/extHostTypes/snippetTextEdit.ts

@@ -0,0 +1,44 @@
+//!!! 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 type * as vscode from 'vscode';
+import { SnippetString } from './snippetString';
+import { Position } from './position';
+import { Range } from './range';
+
+export class SnippetTextEdit implements vscode.SnippetTextEdit {
+
+	static isSnippetTextEdit(thing: any): thing is SnippetTextEdit {
+		if (thing instanceof SnippetTextEdit) {
+			return true;
+		}
+		if (!thing) {
+			return false;
+		}
+		return Range.isRange((<SnippetTextEdit>thing).range)
+			&& SnippetString.isSnippetString((<SnippetTextEdit>thing).snippet);
+	}
+
+	static replace(range: Range, snippet: SnippetString): SnippetTextEdit {
+		return new SnippetTextEdit(range, snippet);
+	}
+
+	static insert(position: Position, snippet: SnippetString): SnippetTextEdit {
+		return SnippetTextEdit.replace(new Range(position, position), snippet);
+	}
+
+	range: Range;
+
+	snippet: SnippetString;
+
+	keepWhitespace?: boolean;
+
+	constructor(range: Range, snippet: SnippetString) {
+		this.range = range;
+		this.snippet = snippet;
+	}
+}

package/src/_internal/util/vs/workbench/api/common/extHostTypes/symbolInformation.ts

@@ -0,0 +1,89 @@
+//!!! 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 { URI } from '../../../../base/common/uri';
+import { es5ClassCompat } from './es5ClassCompat';
+import { Location } from './location';
+import { Range } from './range';
+
+export enum SymbolKind {
+	File = 0,
+	Module = 1,
+	Namespace = 2,
+	Package = 3,
+	Class = 4,
+	Method = 5,
+	Property = 6,
+	Field = 7,
+	Constructor = 8,
+	Enum = 9,
+	Interface = 10,
+	Function = 11,
+	Variable = 12,
+	Constant = 13,
+	String = 14,
+	Number = 15,
+	Boolean = 16,
+	Array = 17,
+	Object = 18,
+	Key = 19,
+	Null = 20,
+	EnumMember = 21,
+	Struct = 22,
+	Event = 23,
+	Operator = 24,
+	TypeParameter = 25
+}
+
+export enum SymbolTag {
+	Deprecated = 1
+}
+
+@es5ClassCompat
+export class SymbolInformation {
+
+	static validate(candidate: SymbolInformation): void {
+		if (!candidate.name) {
+			throw new Error('name must not be falsy');
+		}
+	}
+
+	name: string;
+	location!: Location;
+	kind: SymbolKind;
+	tags?: SymbolTag[];
+	containerName: string | undefined;
+
+	constructor(name: string, kind: SymbolKind, containerName: string | undefined, location: Location);
+	constructor(name: string, kind: SymbolKind, range: Range, uri?: URI, containerName?: string);
+	constructor(name: string, kind: SymbolKind, rangeOrContainer: string | undefined | Range, locationOrUri?: Location | URI, containerName?: string) {
+		this.name = name;
+		this.kind = kind;
+		this.containerName = containerName;
+
+		if (typeof rangeOrContainer === 'string') {
+			this.containerName = rangeOrContainer;
+		}
+
+		if (locationOrUri instanceof Location) {
+			this.location = locationOrUri;
+		} else if (rangeOrContainer instanceof Range) {
+			this.location = new Location(locationOrUri!, rangeOrContainer);
+		}
+
+		SymbolInformation.validate(this);
+	}
+
+	toJSON(): any {
+		return {
+			name: this.name,
+			kind: SymbolKind[this.kind],
+			location: this.location,
+			containerName: this.containerName
+		};
+	}
+}