@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/platform/configuration/common/defaultsOnlyConfigurationService.ts

@@ -1,39 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import type { ConfigurationScope } from 'vscode';
-import { IExperimentationService } from '../../telemetry/common/nullExperimentationService';
-import { AbstractConfigurationService, BaseConfig, Config, ExperimentBasedConfig, ExperimentBasedConfigType, InspectConfigResult } from './configurationService';
-
-/** Provides only the default values, ignoring the user's settings or exp. */
-
-export class DefaultsOnlyConfigurationService extends AbstractConfigurationService {
-
-	override getConfig<T>(key: Config<T>): T {
-		return this.getDefaultValue(key);
-	}
-
-	override inspectConfig<T>(key: BaseConfig<T>, scope?: ConfigurationScope): InspectConfigResult<T> | undefined {
-		return {
-			defaultValue: this.getDefaultValue(key),
-		};
-	}
-
-	override setConfig(): Promise<void> {
-		return Promise.resolve();
-	}
-
-	override getNonExtensionConfig<T>(configKey: string): T | undefined {
-		return undefined;
-	}
-
-	override getExperimentBasedConfig<T extends ExperimentBasedConfigType>(key: ExperimentBasedConfig<T>, experimentationService: IExperimentationService, scope?: ConfigurationScope): T {
-		return this.getDefaultValue(key);
-	}
-
-	override dumpConfig(): { [key: string]: string } {
-		return {};
-	}
-}

package/src/_internal/platform/configuration/common/jsonSchema.ts

@@ -1,139 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export type JsonSchema =
-	| NumericJsonSchema
-	| StringJsonSchema
-	| ArrayJsonSchema
-	| ObjectJsonSchema
-	| JsonSchemaReference
-	| EmptyJsonSchema;
-
-export interface EmptyJsonSchema { }
-
-export interface JsonSchemaReference {
-	$ref: string;
-}
-
-export interface BaseJsonSchema {
-	$id?: string;
-	$schema?: string;
-	title?: string;
-	description?: string;
-
-	definitions?: {
-		[name: string]: JsonSchema;
-	};
-
-	enum?: unknown[];
-	format?: string | Format;
-
-	if?: JsonSchema;
-	then?: JsonSchema;
-	else?: JsonSchema;
-	allOf?: JsonSchema[];
-	anyOf?: JsonSchema[];
-	oneOf?: JsonSchema[];
-	not?: JsonSchema;
-}
-
-export type Format =
-	| typeof Format.dateTime
-	| typeof Format.date
-	| typeof Format.time
-	| typeof Format.email
-	| typeof Format.idnEmail
-	| typeof Format.hostname
-	| typeof Format.idnHostname
-	| typeof Format.ipv4
-	| typeof Format.ipv6
-	| typeof Format.uri
-	| typeof Format.uriReference
-	| typeof Format.iri
-	| typeof Format.iriReference
-	| typeof Format.uriTemplate
-	| typeof Format.jsonPointer
-	| typeof Format.relativeJsonPointer
-	| typeof Format.regex;
-
-export namespace Format {
-	export const dateTime = "date-time";
-	export const date = "date";
-	export const time = "time";
-	export const email = "email";
-	export const idnEmail = "idn-email";
-	export const hostname = "hostname";
-	export const idnHostname = "idn-hostname";
-	export const ipv4 = "ipv4";
-	export const ipv6 = "ipv6";
-	export const uri = "uri";
-	export const uriReference = "uri-reference";
-	export const iri = "iri";
-	export const iriReference = "iri-reference";
-	export const uriTemplate = "uri-template";
-	export const jsonPointer = "json-pointer";
-	export const relativeJsonPointer = "relative-json-pointer";
-	export const regex = "regex";
-}
-
-export interface NumericJsonSchema extends BaseJsonSchema {
-	type: JsonSchemaType.Numeric | JsonSchemaType[];
-	multipleOf?: number;
-	maximum?: number;
-	exclusiveMaximum?: boolean;
-	minimum?: number;
-	exclusiveMinimum?: boolean;
-}
-
-export interface StringJsonSchema extends BaseJsonSchema {
-	type: typeof JsonSchemaType.string | JsonSchemaType[];
-	maxLength?: number;
-	minLength?: number;
-	pattern?: string;
-}
-
-export interface ArrayJsonSchema extends BaseJsonSchema {
-	type: typeof JsonSchemaType.array | JsonSchemaType[];
-	items?: JsonSchema | JsonSchema[];
-	additionalItems?: JsonSchema;
-	maxItems?: number;
-	minItems?: number;
-	uniqueItems?: boolean;
-	contains: JsonSchema;
-}
-
-export interface ObjectJsonSchema extends BaseJsonSchema {
-	type: typeof JsonSchemaType.object | JsonSchemaType[];
-	maxProperties?: number;
-	minProperties?: number;
-	required?: string[];
-	properties?: {
-		[name: string]: JsonSchema;
-	};
-	patternProperties?: {
-		[name: string]: JsonSchema;
-	};
-	additionalProperties?: JsonSchema;
-	dependencies?: {
-		[name: string]: JsonSchema | string[];
-	};
-}
-
-namespace JsonSchemaType {
-	export const number = "number";
-	export const integer = "integer";
-	export const array = "array";
-	export const object = "object";
-	export const string = "string";
-	export type Numeric = typeof number | typeof integer;
-}
-
-export type JsonSchemaType =
-	| "null"
-	| "boolean"
-	| typeof JsonSchemaType.object
-	| typeof JsonSchemaType.array
-	| typeof JsonSchemaType.string
-	| JsonSchemaType.Numeric;

package/src/_internal/platform/configuration/common/validator.ts

@@ -1,242 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { JsonSchema } from './jsonSchema';
-
-export interface IValidator<T> {
-	validate(content: unknown): { content: T; error: undefined } | { content: undefined; error: ValidationError };
-
-	toSchema(): JsonSchema;
-}
-
-export type ValidatorType<T> = T extends IValidator<infer U> ? U : never;
-
-export interface ValidationError {
-	message: string;
-}
-
-interface TypeOfMap {
-	string: string;
-	number: number;
-	boolean: boolean;
-	object: object;
-	undefined: undefined;
-	function: Function;
-	symbol: symbol;
-}
-
-class TypeofValidator<TKey extends keyof TypeOfMap> implements IValidator<TypeOfMap[TKey]> {
-	constructor(private readonly type: TKey) { }
-
-	validate(content: unknown): { content: TypeOfMap[TKey]; error: undefined } | { content: undefined; error: ValidationError } {
-		if (typeof content !== this.type) {
-			return { content: undefined, error: { message: `Expected ${this.type}, but got ${typeof content}` } };
-		}
-
-		return { content: content as TypeOfMap[TKey], error: undefined };
-	}
-
-	toSchema(): JsonSchema {
-		return { type: this.type };
-	}
-}
-
-const vStringValidator = new TypeofValidator("string");
-export function vString(): IValidator<string> { return vStringValidator; }
-
-const vNumberValidator = new TypeofValidator("number");
-export function vNumber(): IValidator<number> { return vNumberValidator; }
-
-const vBooleanValidator = new TypeofValidator("boolean");
-export function vBoolean(): IValidator<boolean> { return vBooleanValidator; }
-
-const vObjAnyValidator = new TypeofValidator("object");
-export function vObjAny(): IValidator<object> { return vObjAnyValidator; }
-
-const vUndefinedValidator = new TypeofValidator("undefined");
-export function vUndefined(): IValidator<undefined> { return vUndefinedValidator; }
-
-export function vUnchecked<T>(): IValidator<T> {
-	return {
-		validate(content: unknown): { content: T; error: undefined } {
-			return { content: content as T, error: undefined };
-		},
-		toSchema() {
-			return {
-
-			};
-		},
-	};
-}
-
-export function vUnknown(): IValidator<unknown> {
-	return vUnchecked();
-}
-
-export type ObjectProperties = Record<string, any>;
-
-export function vObj<T extends Record<string, IValidator<any>>>(properties: T): IValidator<{ [K in keyof T]: ValidatorType<T[K]> }> {
-	return {
-		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
-			if (typeof content !== "object" || content === null) {
-				return { content: undefined, error: { message: "Expected object" } };
-			}
-
-			const result: any = {};
-			for (const key in properties) {
-				const validator = properties[key];
-				const { content: value, error } = validator.validate((content as any)[key]);
-				if (error) {
-					return { content: undefined, error: { message: `Error in property ${key}: ${error.message}` } };
-				}
-
-				result[key] = value;
-			}
-
-			return { content: result, error: undefined };
-		},
-		toSchema() {
-			return {
-				type: "object",
-				properties: Object.fromEntries(Object.entries(properties).map(([key, validator]) => [key, validator.toSchema()])),
-			};
-		}
-	};
-}
-
-export function vArray<T>(validator: IValidator<T>): IValidator<T[]> {
-	return {
-		validate(content: unknown): { content: T[]; error: undefined } | { content: undefined; error: ValidationError } {
-			if (!Array.isArray(content)) {
-				return { content: undefined, error: { message: "Expected array" } };
-			}
-
-			const result: T[] = [];
-			for (let i = 0; i < content.length; i++) {
-				const { content: value, error } = validator.validate(content[i]);
-				if (error) {
-					return { content: undefined, error: { message: `Error in element ${i}: ${error.message}` } };
-				}
-
-				result.push(value);
-			}
-
-			return { content: result, error: undefined };
-		},
-
-		toSchema(): JsonSchema {
-			return {
-				type: "array",
-				items: validator.toSchema(),
-			};
-		}
-	};
-}
-
-export function vTuple<T extends IValidator<any>[]>(...validators: T): IValidator<{ [K in keyof T]: ValidatorType<T[K]> }> {
-	return {
-		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
-			if (!Array.isArray(content)) {
-				return { content: undefined, error: { message: "Expected array" } };
-			}
-
-			if (content.length !== validators.length) {
-				return { content: undefined, error: { message: `Expected tuple of length ${validators.length}, but got ${content.length}` } };
-			}
-
-			const result: any = [];
-			for (let i = 0; i < validators.length; i++) {
-				const validator = validators[i];
-				const { content: value, error } = validator.validate(content[i]);
-				if (error) {
-					return { content: undefined, error: { message: `Error in element ${i}: ${error.message}` } };
-				}
-
-				result.push(value);
-			}
-
-			return { content: result, error: undefined };
-		},
-
-		toSchema(): JsonSchema {
-			return {
-				type: "array",
-				items: validators.map(validator => validator.toSchema()),
-			};
-		}
-	};
-}
-
-export function vUnion<T extends IValidator<any>[]>(...validators: T): IValidator<ValidatorType<T[number]>> {
-	return {
-		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
-			let lastError: ValidationError | undefined;
-			for (const validator of validators) {
-				const { content: value, error } = validator.validate(content);
-				if (!error) {
-					return { content: value, error: undefined };
-				}
-
-				lastError = error;
-			}
-
-			return { content: undefined, error: lastError! };
-		},
-
-		toSchema(): JsonSchema {
-			return {
-				oneOf: validators.map(validator => validator.toSchema()),
-			};
-		}
-	};
-}
-
-export function vEnum<T extends string[]>(...values: T): IValidator<T[number]> {
-	return {
-		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
-			if (values.indexOf(content as any) === -1) {
-				return { content: undefined, error: { message: `Expected one of: ${values.join(", ")}` } };
-			}
-
-			return { content, error: undefined };
-		},
-
-		toSchema(): JsonSchema {
-			return {
-				enum: values,
-			};
-		}
-	};
-}
-
-export function vLiteral<T extends string>(value: T): IValidator<T> {
-	return {
-		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
-			if (content !== value) {
-				return { content: undefined, error: { message: `Expected: ${value}` } };
-			}
-
-			return { content, error: undefined };
-		},
-
-		toSchema(): JsonSchema {
-			return {
-				const: value,
-			};
-		}
-	};
-}
-
-export function vLazy<T>(fn: () => IValidator<T>): IValidator<T> {
-	return {
-		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
-			return fn().validate(content);
-		},
-
-		toSchema(): JsonSchema {
-			return fn().toSchema();
-		}
-	};
-}

package/src/_internal/platform/diff/common/diffService.ts

@@ -1,41 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { createServiceIdentifier } from '../../../util/common/services';
-import { ILinesDiffComputerOptions, MovedText } from '../../../util/vs/editor/common/diff/linesDiffComputer';
-import { DetailedLineRangeMapping } from '../../../util/vs/editor/common/diff/rangeMapping';
-
-
-export const IDiffService = createServiceIdentifier<IDiffService>('IDiffService');
-
-export interface IDiffService {
-
-	readonly _serviceBrand: undefined;
-
-	computeDiff(original: string, modified: string, options: ILinesDiffComputerOptions): Promise<IDocumentDiff>;
-}
-
-export interface IDocumentDiff {
-	/**
-	 * If true, both text models are identical (byte-wise).
-	 */
-	readonly identical: boolean;
-
-	/**
-	 * If true, the diff computation timed out and the diff might not be accurate.
-	 */
-	readonly quitEarly: boolean;
-
-	/**
-	 * Maps all modified line ranges in the original to the corresponding line ranges in the modified text model.
-	 */
-	readonly changes: readonly DetailedLineRangeMapping[];
-
-	/**
-	 * Sorted by original line ranges.
-	 * The original line ranges and the modified line ranges must be disjoint (but can be touching).
-	 */
-	readonly moves: readonly MovedText[];
-}

package/src/_internal/platform/diff/common/diffWorker.ts

@@ -1,83 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { DefaultLinesDiffComputer } from '../../../util/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer';
-import { ILinesDiffComputerOptions } from '../../../util/vs/editor/common/diff/linesDiffComputer';
-import { DetailedLineRangeMapping } from '../../../util/vs/editor/common/diff/rangeMapping';
-
-
-export async function computeDiff(original: string, modified: string, options: ILinesDiffComputerOptions): Promise<IDiffComputationResult> {
-	return computeDiffSync(original, modified, options);
-}
-
-export function computeDiffSync(original: string, modified: string, options: ILinesDiffComputerOptions): IDiffComputationResult {
-	const originalLines = original.split(/\r\n|\r|\n/);
-	const modifiedLines = modified.split(/\r\n|\r|\n/);
-	const diffComputer = new DefaultLinesDiffComputer();
-	const result = diffComputer.computeDiff(originalLines, modifiedLines, options);
-
-	const identical = (result.changes.length > 0 ? false : original === modified);
-
-	function getLineChanges(changes: readonly DetailedLineRangeMapping[]): ILineChange[] {
-		return changes.map(m => ([m.original.startLineNumber, m.original.endLineNumberExclusive, m.modified.startLineNumber, m.modified.endLineNumberExclusive, m.innerChanges?.map(m => [
-			m.originalRange.startLineNumber,
-			m.originalRange.startColumn,
-			m.originalRange.endLineNumber,
-			m.originalRange.endColumn,
-			m.modifiedRange.startLineNumber,
-			m.modifiedRange.startColumn,
-			m.modifiedRange.endLineNumber,
-			m.modifiedRange.endColumn,
-		])]));
-	}
-
-	return {
-		identical,
-		quitEarly: result.hitTimeout,
-		changes: getLineChanges(result.changes),
-		moves: result.moves.map(m => ([
-			m.lineRangeMapping.original.startLineNumber,
-			m.lineRangeMapping.original.endLineNumberExclusive,
-			m.lineRangeMapping.modified.startLineNumber,
-			m.lineRangeMapping.modified.endLineNumberExclusive,
-			getLineChanges(m.changes)
-		])),
-	};
-}
-
-export interface IDiffComputationResult {
-	quitEarly: boolean;
-	changes: ILineChange[];
-	identical: boolean;
-	moves: ITextMove[];
-}
-
-export type ILineChange = [
-	originalStartLine: number,
-	originalEndLine: number,
-	modifiedStartLine: number,
-	modifiedEndLine: number,
-	charChanges: ICharChange[] | undefined,
-];
-
-export type ICharChange = [
-	originalStartLine: number,
-	originalStartColumn: number,
-	originalEndLine: number,
-	originalEndColumn: number,
-
-	modifiedStartLine: number,
-	modifiedStartColumn: number,
-	modifiedEndLine: number,
-	modifiedEndColumn: number,
-];
-
-export type ITextMove = [
-	originalStartLine: number,
-	originalEndLine: number,
-	modifiedStartLine: number,
-	modifiedEndLine: number,
-	changes: ILineChange[],
-];

package/src/_internal/platform/diff/node/diffServiceImpl.ts

@@ -1,85 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { WorkerWithRpcProxy } from '../../../util/node/worker';
-import { Lazy } from '../../../util/vs/base/common/lazy';
-import * as path from '../../../util/vs/base/common/path';
-import { Range } from '../../../util/vs/editor/common/core/range';
-import { LineRange } from '../../../util/vs/editor/common/core/ranges/lineRange';
-
-import { existsSync } from 'fs';
-import { ILinesDiffComputerOptions, MovedText } from '../../../util/vs/editor/common/diff/linesDiffComputer';
-import { DetailedLineRangeMapping, LineRangeMapping, RangeMapping } from '../../../util/vs/editor/common/diff/rangeMapping';
-import { IDiffService, IDocumentDiff } from '../common/diffService';
-import * as diffWorker from '../common/diffWorker';
-
-export class DiffServiceImpl implements IDiffService {
-
-	declare readonly _serviceBrand: undefined;
-
-	private _worker: Lazy<WorkerWithRpcProxy<typeof diffWorker>>;
-
-	constructor(private _useWorker = true) {
-		this._worker = new Lazy(() => {
-			const workerPath = firstExistingPath([
-				path.join(__dirname, 'diffWorker.js'), // after bundling by esbuild
-				path.join(__dirname, '../../../../dist/diffWorker.js'), // relative to the typescript source file (for tsx)
-			]);
-
-			if (workerPath === undefined) {
-				throw new Error('DiffServiceImpl: worker file not found');
-			}
-
-			return new WorkerWithRpcProxy<typeof diffWorker>(workerPath, {
-				name: 'Diff worker',
-			});
-		});
-	}
-
-	dispose(): void {
-		this._worker.rawValue?.terminate();
-	}
-
-	async computeDiff(original: string, modified: string, options: ILinesDiffComputerOptions): Promise<IDocumentDiff> {
-		const result = this._useWorker ?
-			await this._worker.value.proxy.computeDiff(original, modified, options) :
-			await diffWorker.computeDiff(original, modified, options);
-
-		// Convert from space efficient JSON data to rich objects.
-		const diff: IDocumentDiff = {
-			identical: result.identical,
-			quitEarly: result.quitEarly,
-			changes: toLineRangeMappings(result.changes),
-			moves: result.moves.map(m => new MovedText(
-				new LineRangeMapping(new LineRange(m[0], m[1]), new LineRange(m[2], m[3])),
-				toLineRangeMappings(m[4])
-			))
-		};
-		return diff;
-	}
-}
-
-export function toLineRangeMappings(changes: readonly diffWorker.ILineChange[]): readonly DetailedLineRangeMapping[] {
-	return changes.map(
-		(c) => new DetailedLineRangeMapping(
-			new LineRange(c[0], c[1]),
-			new LineRange(c[2], c[3]),
-			c[4]?.map(
-				(c) => new RangeMapping(
-					new Range(c[0], c[1], c[2], c[3]),
-					new Range(c[4], c[5], c[6], c[7])
-				)
-			)
-		)
-	);
-}
-
-function firstExistingPath(paths: string[]): string | undefined {
-	for (const p of paths) {
-		if (existsSync(p)) {
-			return p;
-		}
-	}
-}