@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/base/common/symbols.ts

@@ -1,11 +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.
- *--------------------------------------------------------------------------------------------*/
-
-/**
- * Can be passed into the Delayed to defer using a microtask
- * */
-export const MicrotaskDelay = Symbol('MicrotaskDelay');

package/src/_internal/util/vs/base/common/themables.ts

@@ -1,106 +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 { Codicon } from './codicons';
-
-export type ColorIdentifier = string;
-
-export type IconIdentifier = string;
-
-export interface ThemeColor {
-	id: string;
-}
-
-export namespace ThemeColor {
-	export function isThemeColor(obj: unknown): obj is ThemeColor {
-		return !!obj && typeof obj === 'object' && typeof (<ThemeColor>obj).id === 'string';
-	}
-}
-
-export function themeColorFromId(id: ColorIdentifier) {
-	return { id };
-}
-
-
-export interface ThemeIcon {
-	readonly id: string;
-	readonly color?: ThemeColor;
-}
-
-export namespace ThemeIcon {
-	export const iconNameSegment = '[A-Za-z0-9]+';
-	export const iconNameExpression = '[A-Za-z0-9-]+';
-	export const iconModifierExpression = '~[A-Za-z]+';
-	export const iconNameCharacter = '[A-Za-z0-9~-]';
-
-	const ThemeIconIdRegex = new RegExp(`^(${iconNameExpression})(${iconModifierExpression})?$`);
-
-	export function asClassNameArray(icon: ThemeIcon): string[] {
-		const match = ThemeIconIdRegex.exec(icon.id);
-		if (!match) {
-			return asClassNameArray(Codicon.error);
-		}
-		const [, id, modifier] = match;
-		const classNames = ['codicon', 'codicon-' + id];
-		if (modifier) {
-			classNames.push('codicon-modifier-' + modifier.substring(1));
-		}
-		return classNames;
-	}
-
-	export function asClassName(icon: ThemeIcon): string {
-		return asClassNameArray(icon).join(' ');
-	}
-
-	export function asCSSSelector(icon: ThemeIcon): string {
-		return '.' + asClassNameArray(icon).join('.');
-	}
-
-	export function isThemeIcon(obj: unknown): obj is ThemeIcon {
-		return !!obj && typeof obj === 'object' && typeof (<ThemeIcon>obj).id === 'string' && (typeof (<ThemeIcon>obj).color === 'undefined' || ThemeColor.isThemeColor((<ThemeIcon>obj).color));
-	}
-
-	const _regexFromString = new RegExp(`^\\$\\((${ThemeIcon.iconNameExpression}(?:${ThemeIcon.iconModifierExpression})?)\\)$`);
-
-	export function fromString(str: string): ThemeIcon | undefined {
-		const match = _regexFromString.exec(str);
-		if (!match) {
-			return undefined;
-		}
-		const [, name] = match;
-		return { id: name };
-	}
-
-	export function fromId(id: string): ThemeIcon {
-		return { id };
-	}
-
-	export function modify(icon: ThemeIcon, modifier: 'disabled' | 'spin' | undefined): ThemeIcon {
-		let id = icon.id;
-		const tildeIndex = id.lastIndexOf('~');
-		if (tildeIndex !== -1) {
-			id = id.substring(0, tildeIndex);
-		}
-		if (modifier) {
-			id = `${id}~${modifier}`;
-		}
-		return { id };
-	}
-
-	export function getModifier(icon: ThemeIcon): string | undefined {
-		const tildeIndex = icon.id.lastIndexOf('~');
-		if (tildeIndex !== -1) {
-			return icon.id.substring(tildeIndex + 1);
-		}
-		return undefined;
-	}
-
-	export function isEqual(ti1: ThemeIcon, ti2: ThemeIcon): boolean {
-		return ti1.id === ti2.id && ti1.color?.id === ti2.color?.id;
-	}
-
-}

package/src/_internal/util/vs/base/common/types.ts

@@ -1,345 +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 './assert';
-
-/**
- * @returns whether the provided parameter is a JavaScript String or not.
- */
-export function isString(str: unknown): str is string {
-	return (typeof str === 'string');
-}
-
-/**
- * @returns whether the provided parameter is a JavaScript Array and each element in the array is a string.
- */
-export function isStringArray(value: unknown): value is string[] {
-	return Array.isArray(value) && (<unknown[]>value).every(elem => isString(elem));
-}
-
-/**
- * @returns whether the provided parameter is of type `object` but **not**
- *	`null`, an `array`, a `regexp`, nor a `date`.
- */
-export function isObject(obj: unknown): obj is Object {
-	// The method can't do a type cast since there are type (like strings) which
-	// are subclasses of any put not positvely matched by the function. Hence type
-	// narrowing results in wrong results.
-	return typeof obj === 'object'
-		&& obj !== null
-		&& !Array.isArray(obj)
-		&& !(obj instanceof RegExp)
-		&& !(obj instanceof Date);
-}
-
-/**
- * @returns whether the provided parameter is of type `Buffer` or Uint8Array dervived type
- */
-export function isTypedArray(obj: unknown): obj is Object {
-	const TypedArray = Object.getPrototypeOf(Uint8Array);
-	return typeof obj === 'object'
-		&& obj instanceof TypedArray;
-}
-
-/**
- * In **contrast** to just checking `typeof` this will return `false` for `NaN`.
- * @returns whether the provided parameter is a JavaScript Number or not.
- */
-export function isNumber(obj: unknown): obj is number {
-	return (typeof obj === 'number' && !isNaN(obj));
-}
-
-/**
- * @returns whether the provided parameter is an Iterable, casting to the given generic
- */
-export function isIterable<T>(obj: unknown): obj is Iterable<T> {
-	return !!obj && typeof (obj as any)[Symbol.iterator] === 'function';
-}
-
-/**
- * @returns whether the provided parameter is an Iterable, casting to the given generic
- */
-export function isAsyncIterable<T>(obj: unknown): obj is AsyncIterable<T> {
-	return !!obj && typeof (obj as any)[Symbol.asyncIterator] === 'function';
-}
-
-/**
- * @returns whether the provided parameter is a JavaScript Boolean or not.
- */
-export function isBoolean(obj: unknown): obj is boolean {
-	return (obj === true || obj === false);
-}
-
-/**
- * @returns whether the provided parameter is undefined.
- */
-export function isUndefined(obj: unknown): obj is undefined {
-	return (typeof obj === 'undefined');
-}
-
-/**
- * @returns whether the provided parameter is defined.
- */
-export function isDefined<T>(arg: T | null | undefined): arg is T {
-	return !isUndefinedOrNull(arg);
-}
-
-/**
- * @returns whether the provided parameter is undefined or null.
- */
-export function isUndefinedOrNull(obj: unknown): obj is undefined | null {
-	return (isUndefined(obj) || obj === null);
-}
-
-
-export function assertType(condition: unknown, type?: string): asserts condition {
-	if (!condition) {
-		throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');
-	}
-}
-
-/**
- * Asserts that the argument passed in is neither undefined nor null.
- *
- * @see {@link assertDefined} for a similar utility that leverages TS assertion functions to narrow down the type of `arg` to be non-nullable.
- */
-export function assertReturnsDefined<T>(arg: T | null | undefined): NonNullable<T> {
-	assert(
-		arg !== null && arg !== undefined,
-		'Argument is `undefined` or `null`.',
-	);
-
-	return arg;
-}
-
-/**
- * Asserts that a provided `value` is `defined` - not `null` or `undefined`,
- * throwing an error with the provided error or error message, while also
- * narrowing down the type of the `value` to be `NonNullable` using TS
- * assertion functions.
- *
- * @throws if the provided `value` is `null` or `undefined`.
- *
- * ## Examples
- *
- * ```typescript
- * // an assert with an error message
- * assertDefined('some value', 'String constant is not defined o_O.');
- *
- * // `throws!` the provided error
- * assertDefined(null, new Error('Should throw this error.'));
- *
- * // narrows down the type of `someValue` to be non-nullable
- * const someValue: string | undefined | null = blackbox();
- * assertDefined(someValue, 'Some value must be defined.');
- * console.log(someValue.length); // now type of `someValue` is `string`
- * ```
- *
- * @see {@link assertReturnsDefined} for a similar utility but without assertion.
- * @see {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions typescript-3-7.html#assertion-functions}
- */
-export function assertDefined<T>(value: T, error: string | NonNullable<Error>): asserts value is NonNullable<T> {
-	if (value === null || value === undefined) {
-		const errorToThrow = typeof error === 'string' ? new Error(error) : error;
-
-		throw errorToThrow;
-	}
-}
-
-/**
- * Asserts that each argument passed in is neither undefined nor null.
- */
-export function assertReturnsAllDefined<T1, T2>(t1: T1 | null | undefined, t2: T2 | null | undefined): [T1, T2];
-export function assertReturnsAllDefined<T1, T2, T3>(t1: T1 | null | undefined, t2: T2 | null | undefined, t3: T3 | null | undefined): [T1, T2, T3];
-export function assertReturnsAllDefined<T1, T2, T3, T4>(t1: T1 | null | undefined, t2: T2 | null | undefined, t3: T3 | null | undefined, t4: T4 | null | undefined): [T1, T2, T3, T4];
-export function assertReturnsAllDefined(...args: (unknown | null | undefined)[]): unknown[] {
-	const result = [];
-
-	for (let i = 0; i < args.length; i++) {
-		const arg = args[i];
-
-		if (isUndefinedOrNull(arg)) {
-			throw new Error(`Assertion Failed: argument at index ${i} is undefined or null`);
-		}
-
-		result.push(arg);
-	}
-
-	return result;
-}
-
-/**
- * Checks if the provided value is one of the vales in the provided list.
- *
- * ## Examples
- *
- * ```typescript
- * // note! item type is a `subset of string`
- * type TItem = ':' | '.' | '/';
- *
- * // note! item is type of `string` here
- * const item: string = ':';
- * // list of the items to check against
- * const list: TItem[] = [':', '.'];
- *
- * // ok
- * assert(
- *   isOneOf(item, list),
- *   'Must succeed.',
- * );
- *
- * // `item` is of `TItem` type now
- * ```
- */
-export const isOneOf = <TType, TSubtype extends TType>(
-	value: TType,
-	validValues: readonly TSubtype[],
-): value is TSubtype => {
-	// note! it is OK to type cast here, because we rely on the includes
-	//       utility to check if the value is present in the provided list
-	return validValues.includes(<TSubtype>value);
-};
-
-/**
- * Compile-time type check of a variable.
- */
-export function typeCheck<T = never>(_thing: NoInfer<T>): void { }
-
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-
-/**
- * @returns whether the provided parameter is an empty JavaScript Object or not.
- */
-export function isEmptyObject(obj: unknown): obj is object {
-	if (!isObject(obj)) {
-		return false;
-	}
-
-	for (const key in obj) {
-		if (hasOwnProperty.call(obj, key)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-/**
- * @returns whether the provided parameter is a JavaScript Function or not.
- */
-export function isFunction(obj: unknown): obj is Function {
-	return (typeof obj === 'function');
-}
-
-/**
- * @returns whether the provided parameters is are JavaScript Function or not.
- */
-export function areFunctions(...objects: unknown[]): boolean {
-	return objects.length > 0 && objects.every(isFunction);
-}
-
-export type TypeConstraint = string | Function;
-
-export function validateConstraints(args: unknown[], constraints: Array<TypeConstraint | undefined>): void {
-	const len = Math.min(args.length, constraints.length);
-	for (let i = 0; i < len; i++) {
-		validateConstraint(args[i], constraints[i]);
-	}
-}
-
-export function validateConstraint(arg: unknown, constraint: TypeConstraint | undefined): void {
-
-	if (isString(constraint)) {
-		if (typeof arg !== constraint) {
-			throw new Error(`argument does not match constraint: typeof ${constraint}`);
-		}
-	} else if (isFunction(constraint)) {
-		try {
-			if (arg instanceof constraint) {
-				return;
-			}
-		} catch {
-			// ignore
-		}
-		if (!isUndefinedOrNull(arg) && (arg as any).constructor === constraint) {
-			return;
-		}
-		if (constraint.length === 1 && constraint.call(undefined, arg) === true) {
-			return;
-		}
-		throw new Error(`argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true`);
-	}
-}
-
-/**
- * Helper type assertion that safely upcasts a type to a supertype.
- *
- * This can be used to make sure the argument correctly conforms to the subtype while still being able to pass it
- * to contexts that expects the supertype.
- */
-export function upcast<Base, Sub extends Base = Base>(x: Sub): Base {
-	return x;
-}
-
-type AddFirstParameterToFunction<T, TargetFunctionsReturnType, FirstParameter> = T extends (...args: any[]) => TargetFunctionsReturnType ?
-	// Function: add param to function
-	(firstArg: FirstParameter, ...args: Parameters<T>) => ReturnType<T> :
-
-	// Else: just leave as is
-	T;
-
-/**
- * Allows to add a first parameter to functions of a type.
- */
-export type AddFirstParameterToFunctions<Target, TargetFunctionsReturnType, FirstParameter> = {
-	// For every property
-	[K in keyof Target]: AddFirstParameterToFunction<Target[K], TargetFunctionsReturnType, FirstParameter>;
-};
-
-/**
- * Given an object with all optional properties, requires at least one to be defined.
- * i.e. AtLeastOne<MyObject>;
- */
-export type AtLeastOne<T, U = { [K in keyof T]: Pick<T, K> }> = Partial<T> & U[keyof U];
-
-/**
- * Only picks the non-optional properties of a type.
- */
-export type OmitOptional<T> = { [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K] };
-
-/**
- * A type that removed readonly-less from all properties of `T`
- */
-export type Mutable<T> = {
-	-readonly [P in keyof T]: T[P]
-};
-
-/**
- * A single object or an array of the objects.
- */
-export type SingleOrMany<T> = T | T[];
-
-
-/**
- * A type that recursively makes all properties of `T` required
- */
-export type DeepRequiredNonNullable<T> = {
-	[P in keyof T]-?: T[P] extends object ? DeepRequiredNonNullable<T[P]> : Required<NonNullable<T[P]>>;
-};
-
-
-/**
- * Represents a type that is a partial version of a given type `T`, where all properties are optional and can be deeply nested.
- */
-export type DeepPartial<T> = {
-	[P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : Partial<T[P]>;
-};
-
-/**
- * Represents a type that is a partial version of a given type `T`, except a subset.
- */
-export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;

package/src/_internal/util/vs/base/common/uint.ts

@@ -1,61 +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.
- *--------------------------------------------------------------------------------------------*/
-
-export const enum Constants {
-	/**
-	 * MAX SMI (SMall Integer) as defined in v8.
-	 * one bit is lost for boxing/unboxing flag.
-	 * one bit is lost for sign flag.
-	 * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
-	 */
-	MAX_SAFE_SMALL_INTEGER = 1 << 30,
-
-	/**
-	 * MIN SMI (SMall Integer) as defined in v8.
-	 * one bit is lost for boxing/unboxing flag.
-	 * one bit is lost for sign flag.
-	 * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
-	 */
-	MIN_SAFE_SMALL_INTEGER = -(1 << 30),
-
-	/**
-	 * Max unsigned integer that fits on 8 bits.
-	 */
-	MAX_UINT_8 = 255, // 2^8 - 1
-
-	/**
-	 * Max unsigned integer that fits on 16 bits.
-	 */
-	MAX_UINT_16 = 65535, // 2^16 - 1
-
-	/**
-	 * Max unsigned integer that fits on 32 bits.
-	 */
-	MAX_UINT_32 = 4294967295, // 2^32 - 1
-
-	UNICODE_SUPPLEMENTARY_PLANE_BEGIN = 0x010000
-}
-
-export function toUint8(v: number): number {
-	if (v < 0) {
-		return 0;
-	}
-	if (v > Constants.MAX_UINT_8) {
-		return Constants.MAX_UINT_8;
-	}
-	return v | 0;
-}
-
-export function toUint32(v: number): number {
-	if (v < 0) {
-		return 0;
-	}
-	if (v > Constants.MAX_UINT_32) {
-		return Constants.MAX_UINT_32;
-	}
-	return v | 0;
-}