@codingame/monaco-vscode-api 22.1.8 → 23.0.0

package/vscode/src/vs/base/common/async.js

@@ -126,13 +126,13 @@ function promiseWithResolvers() {
 }
 class Throttler {
     constructor() {
-        this.isDisposed = false;
         this.activePromise = null;
         this.queuedPromise = null;
         this.queuedPromiseFactory = null;
+        this.cancellationTokenSource = ( new CancellationTokenSource());
     }
     queue(promiseFactory) {
-        if (this.isDisposed) {
+        if (this.cancellationTokenSource.token.isCancellationRequested) {
             return Promise.reject(( new Error('Throttler is disposed')));
         }
         if (this.activePromise) {
@@ -140,7 +140,7 @@ class Throttler {
             if (!this.queuedPromise) {
                 const onComplete = () => {
                     this.queuedPromise = null;
-                    if (this.isDisposed) {
+                    if (this.cancellationTokenSource.token.isCancellationRequested) {
                         return;
                     }
                     const result = this.queue(this.queuedPromiseFactory);
@@ -155,7 +155,7 @@ class Throttler {
                 this.queuedPromise.then(resolve, reject);
             }));
         }
-        this.activePromise = promiseFactory();
+        this.activePromise = promiseFactory(this.cancellationTokenSource.token);
         return ( new Promise((resolve, reject) => {
             this.activePromise.then((result) => {
                 this.activePromise = null;
@@ -167,7 +167,7 @@ class Throttler {
         }));
     }
     dispose() {
-        this.isDisposed = true;
+        this.cancellationTokenSource.cancel();
     }
 }
 class Sequencer {
@@ -195,6 +195,9 @@ class SequencerByKey {
         this.promiseMap.set(key, newPromise);
         return newPromise;
     }
+    peek(key) {
+        return this.promiseMap.get(key) || undefined;
+    }
     keys() {
         return ( this.promiseMap.keys());
     }
@@ -863,8 +866,8 @@ class TaskSequentializer {
             this._queued = {
                 run,
                 promise,
-                promiseResolve: promiseResolve,
-                promiseReject: promiseReject
+                promiseResolve,
+                promiseReject
             };
         }
         else {
@@ -902,6 +905,11 @@ var DeferredOutcome;
     DeferredOutcome[DeferredOutcome["Rejected"] = 1] = "Rejected";
 })(DeferredOutcome || (DeferredOutcome = {}));
 class DeferredPromise {
+    static fromPromise(promise) {
+        const deferred = ( new DeferredPromise());
+        deferred.settleWith(promise);
+        return deferred;
+    }
     get isRejected() {
         return this.outcome?.outcome === DeferredOutcome.Rejected;
     }

package/vscode/src/vs/base/common/cache.d.ts

@@ -43,4 +43,15 @@ export declare class CachedFunction<TArg, TComputed> {
     constructor(options: ICacheOptions<TArg>, fn: (arg: TArg) => TComputed);
     get(arg: TArg): TComputed;
 }
+/**
+ * Uses an unbounded cache to memoize the results of the given function.
+*/
+export declare class WeakCachedFunction<TArg, TComputed> {
+    private readonly _map;
+    private readonly _fn;
+    private readonly _computeKey;
+    constructor(fn: (arg: TArg) => TComputed);
+    constructor(options: ICacheOptions<TArg>, fn: (arg: TArg) => TComputed);
+    get(arg: TArg): TComputed;
+}
 export {};

package/vscode/src/vs/base/common/codicons.d.ts

@@ -95,9 +95,6 @@ export declare const Codicon: {
     readonly personFollow: ThemeIcon;
     readonly personOutline: ThemeIcon;
     readonly personFilled: ThemeIcon;
-    readonly gitBranch: ThemeIcon;
-    readonly gitBranchCreate: ThemeIcon;
-    readonly gitBranchDelete: ThemeIcon;
     readonly sourceControl: ThemeIcon;
     readonly mirror: ThemeIcon;
     readonly mirrorPublic: ThemeIcon;
@@ -146,7 +143,6 @@ export declare const Codicon: {
     readonly vm: ThemeIcon;
     readonly deviceDesktop: ThemeIcon;
     readonly file: ThemeIcon;
-    readonly fileText: ThemeIcon;
     readonly more: ThemeIcon;
     readonly ellipsis: ThemeIcon;
     readonly kebabHorizontal: ThemeIcon;
@@ -680,4 +676,30 @@ export declare const Codicon: {
     readonly collection: ThemeIcon;
     readonly newCollection: ThemeIcon;
     readonly thinking: ThemeIcon;
+    readonly build: ThemeIcon;
+    readonly commentDiscussionQuote: ThemeIcon;
+    readonly cursor: ThemeIcon;
+    readonly eraser: ThemeIcon;
+    readonly fileText: ThemeIcon;
+    readonly gitLens: ThemeIcon;
+    readonly quotes: ThemeIcon;
+    readonly rename: ThemeIcon;
+    readonly runWithDeps: ThemeIcon;
+    readonly debugConnected: ThemeIcon;
+    readonly strikethrough: ThemeIcon;
+    readonly openInProduct: ThemeIcon;
+    readonly indexZero: ThemeIcon;
+    readonly agent: ThemeIcon;
+    readonly editCode: ThemeIcon;
+    readonly repoSelected: ThemeIcon;
+    readonly skip: ThemeIcon;
+    readonly mergeInto: ThemeIcon;
+    readonly gitBranchChanges: ThemeIcon;
+    readonly gitBranchStagedChanges: ThemeIcon;
+    readonly gitBranchConflicts: ThemeIcon;
+    readonly gitBranch: ThemeIcon;
+    readonly gitBranchCreate: ThemeIcon;
+    readonly gitBranchDelete: ThemeIcon;
+    readonly searchLarge: ThemeIcon;
+    readonly terminalGitBash: ThemeIcon;
 };

package/vscode/src/vs/base/common/codiconsLibrary.d.ts

@@ -21,9 +21,6 @@ export declare const codiconsLibrary: {
     readonly personFollow: import("./themables.js").ThemeIcon;
     readonly personOutline: import("./themables.js").ThemeIcon;
     readonly personFilled: import("./themables.js").ThemeIcon;
-    readonly gitBranch: import("./themables.js").ThemeIcon;
-    readonly gitBranchCreate: import("./themables.js").ThemeIcon;
-    readonly gitBranchDelete: import("./themables.js").ThemeIcon;
     readonly sourceControl: import("./themables.js").ThemeIcon;
     readonly mirror: import("./themables.js").ThemeIcon;
     readonly mirrorPublic: import("./themables.js").ThemeIcon;
@@ -72,7 +69,6 @@ export declare const codiconsLibrary: {
     readonly vm: import("./themables.js").ThemeIcon;
     readonly deviceDesktop: import("./themables.js").ThemeIcon;
     readonly file: import("./themables.js").ThemeIcon;
-    readonly fileText: import("./themables.js").ThemeIcon;
     readonly more: import("./themables.js").ThemeIcon;
     readonly ellipsis: import("./themables.js").ThemeIcon;
     readonly kebabHorizontal: import("./themables.js").ThemeIcon;
@@ -606,4 +602,30 @@ export declare const codiconsLibrary: {
     readonly collection: import("./themables.js").ThemeIcon;
     readonly newCollection: import("./themables.js").ThemeIcon;
     readonly thinking: import("./themables.js").ThemeIcon;
+    readonly build: import("./themables.js").ThemeIcon;
+    readonly commentDiscussionQuote: import("./themables.js").ThemeIcon;
+    readonly cursor: import("./themables.js").ThemeIcon;
+    readonly eraser: import("./themables.js").ThemeIcon;
+    readonly fileText: import("./themables.js").ThemeIcon;
+    readonly gitLens: import("./themables.js").ThemeIcon;
+    readonly quotes: import("./themables.js").ThemeIcon;
+    readonly rename: import("./themables.js").ThemeIcon;
+    readonly runWithDeps: import("./themables.js").ThemeIcon;
+    readonly debugConnected: import("./themables.js").ThemeIcon;
+    readonly strikethrough: import("./themables.js").ThemeIcon;
+    readonly openInProduct: import("./themables.js").ThemeIcon;
+    readonly indexZero: import("./themables.js").ThemeIcon;
+    readonly agent: import("./themables.js").ThemeIcon;
+    readonly editCode: import("./themables.js").ThemeIcon;
+    readonly repoSelected: import("./themables.js").ThemeIcon;
+    readonly skip: import("./themables.js").ThemeIcon;
+    readonly mergeInto: import("./themables.js").ThemeIcon;
+    readonly gitBranchChanges: import("./themables.js").ThemeIcon;
+    readonly gitBranchStagedChanges: import("./themables.js").ThemeIcon;
+    readonly gitBranchConflicts: import("./themables.js").ThemeIcon;
+    readonly gitBranch: import("./themables.js").ThemeIcon;
+    readonly gitBranchCreate: import("./themables.js").ThemeIcon;
+    readonly gitBranchDelete: import("./themables.js").ThemeIcon;
+    readonly searchLarge: import("./themables.js").ThemeIcon;
+    readonly terminalGitBash: import("./themables.js").ThemeIcon;
 };

package/vscode/src/vs/base/common/codiconsLibrary.js

@@ -24,9 +24,6 @@ const codiconsLibrary = {
     personFollow: register('person-follow', 0xea67),
     personOutline: register('person-outline', 0xea67),
     personFilled: register('person-filled', 0xea67),
-    gitBranch: register('git-branch', 0xea68),
-    gitBranchCreate: register('git-branch-create', 0xea68),
-    gitBranchDelete: register('git-branch-delete', 0xea68),
     sourceControl: register('source-control', 0xea68),
     mirror: register('mirror', 0xea69),
     mirrorPublic: register('mirror-public', 0xea69),
@@ -75,7 +72,6 @@ const codiconsLibrary = {
     vm: register('vm', 0xea7a),
     deviceDesktop: register('device-desktop', 0xea7a),
     file: register('file', 0xea7b),
-    fileText: register('file-text', 0xea7b),
     more: register('more', 0xea7c),
     ellipsis: register('ellipsis', 0xea7c),
     kebabHorizontal: register('kebab-horizontal', 0xea7c),
@@ -609,6 +605,32 @@ const codiconsLibrary = {
     collection: register('collection', 0xec57),
     newCollection: register('new-collection', 0xec58),
     thinking: register('thinking', 0xec59),
+    build: register('build', 0xec5a),
+    commentDiscussionQuote: register('comment-discussion-quote', 0xec5b),
+    cursor: register('cursor', 0xec5c),
+    eraser: register('eraser', 0xec5d),
+    fileText: register('file-text', 0xec5e),
+    gitLens: register('git-lens', 0xec5f),
+    quotes: register('quotes', 0xec60),
+    rename: register('rename', 0xec61),
+    runWithDeps: register('run-with-deps', 0xec62),
+    debugConnected: register('debug-connected', 0xec63),
+    strikethrough: register('strikethrough', 0xec64),
+    openInProduct: register('open-in-product', 0xec65),
+    indexZero: register('index-zero', 0xec66),
+    agent: register('agent', 0xec67),
+    editCode: register('edit-code', 0xec68),
+    repoSelected: register('repo-selected', 0xec69),
+    skip: register('skip', 0xec6a),
+    mergeInto: register('merge-into', 0xec6b),
+    gitBranchChanges: register('git-branch-changes', 0xec6c),
+    gitBranchStagedChanges: register('git-branch-staged-changes', 0xec6d),
+    gitBranchConflicts: register('git-branch-conflicts', 0xec6e),
+    gitBranch: register('git-branch', 0xec6f),
+    gitBranchCreate: register('git-branch-create', 0xec6f),
+    gitBranchDelete: register('git-branch-delete', 0xec6f),
+    searchLarge: register('search-large', 0xec70),
+    terminalGitBash: register('terminal-git-bash', 0xec71),
 };
 
 export { codiconsLibrary };

package/vscode/src/vs/base/common/collections.d.ts

@@ -12,7 +12,7 @@ export type INumberDictionary<V> = Record<number, V>;
  * Groups the collection into a dictionary based on the provided
  * group function.
  */
-export declare function groupBy<K extends string | number | symbol, V>(data: V[], groupFn: (element: V) => K): Record<K, V[]>;
+export declare function groupBy<K extends string | number | symbol, V>(data: readonly V[], groupFn: (element: V) => K): Partial<Record<K, V[]>>;
 export declare function groupByMap<K, V>(data: V[], groupFn: (element: V) => K): Map<K, V[]>;
 export declare function diffSets<T>(before: ReadonlySet<T>, after: ReadonlySet<T>): {
     removed: T[];

package/vscode/src/vs/base/common/decorators/cancelPreviousCalls.d.ts

@@ -77,7 +77,7 @@ type TWithOptionalCancellationToken<TFunction extends Function> = TFunction exte
  * example.doSomethingAsync(2, 'bar');
  * ```
  */
-export declare function cancelPreviousCalls<TObject extends Disposable, TArgs extends unknown[], TReturn extends unknown>(_proto: TObject, methodName: string, descriptor: TypedPropertyDescriptor<TWithOptionalCancellationToken<(...args: TArgs) => TReturn>>): TypedPropertyDescriptor<(...args: [
+export declare function cancelPreviousCalls<TObject extends Disposable, TArgs extends unknown[], TReturn>(_proto: TObject, methodName: string, descriptor: TypedPropertyDescriptor<TWithOptionalCancellationToken<(...args: TArgs) => TReturn>>): TypedPropertyDescriptor<(...args: [
     ...TArgs,
     cancellatioNToken?: CancellationToken | undefined
 ]) => TReturn>;

package/vscode/src/vs/base/common/extpath.js

@@ -197,13 +197,13 @@ function indexOfPath(path, candidate, ignoreCase) {
 }
 function parseLineAndColumnAware(rawPath) {
     const segments = rawPath.split(':');
-    let path = undefined;
-    let line = undefined;
-    let column = undefined;
+    let path;
+    let line;
+    let column;
     for (const segment of segments) {
         const segmentAsNumber = Number(segment);
         if (!isNumber(segmentAsNumber)) {
-            path = !!path ? [path, segment].join(':') : segment;
+            path = path ? [path, segment].join(':') : segment;
         }
         else if (line === undefined) {
             line = segmentAsNumber;

package/vscode/src/vs/base/common/glob.d.ts

@@ -24,13 +24,17 @@ export declare const GLOB_SPLIT = "/";
 export declare function splitGlobAware(pattern: string, splitChar: string): string[];
 export type ParsedPattern = (path: string, basename?: string) => boolean;
 export type ParsedExpression = (path: string, basename?: string, hasSibling?: (name: string) => boolean | Promise<boolean>) => string | null | Promise<string | null>;
-interface IGlobOptions {
+export interface IGlobOptions {
     /**
      * Simplify patterns for use as exclusion filters during
      * tree traversal to skip entire subtrees. Cannot be used
      * outside of a tree traversal.
      */
     trimForExclusions?: boolean;
+    /**
+     * Whether glob pattern matching should be case insensitive.
+     */
+    ignoreCase?: boolean;
 }
 declare const FALSE: () => boolean;
 declare const NULL: () => string | null;
@@ -50,8 +54,8 @@ export declare function isEmptyPattern(pattern: ParsedPattern | ParsedExpression
  * * `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
  * * `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
  */
-export declare function match(pattern: string | IRelativePattern, path: string): boolean;
-export declare function match(expression: IExpression, path: string, hasSibling?: (name: string) => boolean): string;
+export declare function match(pattern: string | IRelativePattern, path: string, options?: IGlobOptions): boolean;
+export declare function match(expression: IExpression, path: string, options?: IGlobOptions): boolean;
 /**
  * Simplified glob matching. Supports a subset of glob patterns:
  * * `*` to match zero or more characters in a path segment

package/vscode/src/vs/base/common/glob.js

@@ -6,7 +6,7 @@ import { isEqualOrParent } from './extpath.js';
 import { LRUCache } from './map.js';
 import { sep, posix, basename, extname } from './path.js';
 import { isLinux } from './platform.js';
-import { escapeRegExpCharacters, ltrim } from './strings.js';
+import { escapeRegExpCharacters, endsWithIgnoreCase, equalsIgnoreCase, ltrim } from './strings.js';
 
 function getEmptyExpression() {
     return Object.create(null);
@@ -185,42 +185,49 @@ function parsePattern(arg1, options) {
         pattern = arg1;
     }
     pattern = pattern.trim();
-    const patternKey = `${pattern}_${!!options.trimForExclusions}`;
+    const ignoreCase = options.ignoreCase ?? false;
+    const internalOptions = {
+        ...options,
+        equals: ignoreCase ? equalsIgnoreCase : (a, b) => a === b,
+        endsWith: ignoreCase ? endsWithIgnoreCase : (str, candidate) => str.endsWith(candidate),
+        isEqualOrParent: (base, candidate) => isEqualOrParent(base, candidate, !isLinux || ignoreCase)
+    };
+    const patternKey = `${ignoreCase ? pattern.toLowerCase() : pattern}_${!!options.trimForExclusions}_${ignoreCase}`;
     let parsedPattern = CACHE.get(patternKey);
     if (parsedPattern) {
-        return wrapRelativePattern(parsedPattern, arg1);
+        return wrapRelativePattern(parsedPattern, arg1, internalOptions);
     }
     let match;
     if (T1.test(pattern)) {
-        parsedPattern = trivia1(pattern.substr(4), pattern);
+        parsedPattern = trivia1(pattern.substring(4), pattern, internalOptions);
     }
-    else if (match = T2.exec(trimForExclusions(pattern, options))) {
-        parsedPattern = trivia2(match[1], pattern);
+    else if (match = T2.exec(trimForExclusions(pattern, internalOptions))) {
+        parsedPattern = trivia2(match[1], pattern, internalOptions);
     }
     else if ((options.trimForExclusions ? T3_2 : T3).test(pattern)) {
-        parsedPattern = trivia3(pattern, options);
+        parsedPattern = trivia3(pattern, internalOptions);
     }
-    else if (match = T4.exec(trimForExclusions(pattern, options))) {
-        parsedPattern = trivia4and5(match[1].substr(1), pattern, true);
+    else if (match = T4.exec(trimForExclusions(pattern, internalOptions))) {
+        parsedPattern = trivia4and5(match[1].substring(1), pattern, true, internalOptions);
     }
-    else if (match = T5.exec(trimForExclusions(pattern, options))) {
-        parsedPattern = trivia4and5(match[1], pattern, false);
+    else if (match = T5.exec(trimForExclusions(pattern, internalOptions))) {
+        parsedPattern = trivia4and5(match[1], pattern, false, internalOptions);
     }
     else {
-        parsedPattern = toRegExp(pattern);
+        parsedPattern = toRegExp(pattern, internalOptions);
     }
     CACHE.set(patternKey, parsedPattern);
-    return wrapRelativePattern(parsedPattern, arg1);
+    return wrapRelativePattern(parsedPattern, arg1, internalOptions);
 }
-function wrapRelativePattern(parsedPattern, arg2) {
+function wrapRelativePattern(parsedPattern, arg2, options) {
     if (typeof arg2 === 'string') {
         return parsedPattern;
     }
     const wrappedPattern = function (path, basename) {
-        if (!isEqualOrParent(path, arg2.base, !isLinux)) {
+        if (!options.isEqualOrParent(path, arg2.base)) {
             return null;
         }
-        return parsedPattern(ltrim(path.substr(arg2.base.length), sep), basename);
+        return parsedPattern(ltrim(path.substring(arg2.base.length), sep), basename);
     };
     wrappedPattern.allBasenames = parsedPattern.allBasenames;
     wrappedPattern.allPaths = parsedPattern.allPaths;
@@ -229,14 +236,14 @@ function wrapRelativePattern(parsedPattern, arg2) {
     return wrappedPattern;
 }
 function trimForExclusions(pattern, options) {
-    return options.trimForExclusions && pattern.endsWith('/**') ? pattern.substr(0, pattern.length - 2) : pattern;
+    return options.trimForExclusions && pattern.endsWith('/**') ? pattern.substring(0, pattern.length - 2) : pattern;
 }
-function trivia1(base, pattern) {
+function trivia1(base, pattern, options) {
     return function (path, basename) {
-        return typeof path === 'string' && path.endsWith(base) ? pattern : null;
+        return typeof path === 'string' && options.endsWith(path, base) ? pattern : null;
     };
 }
-function trivia2(base, pattern) {
+function trivia2(base, pattern, options) {
     const slashBase = `/${base}`;
     const backslashBase = `\\${base}`;
     const parsedPattern = function (path, basename) {
@@ -244,9 +251,9 @@ function trivia2(base, pattern) {
             return null;
         }
         if (basename) {
-            return basename === base ? pattern : null;
+            return options.equals(basename, base) ? pattern : null;
         }
-        return path === base || path.endsWith(slashBase) || path.endsWith(backslashBase) ? pattern : null;
+        return options.equals(path, base) || options.endsWith(path, slashBase) || options.endsWith(path, backslashBase) ? pattern : null;
     };
     const basenames = [base];
     parsedPattern.basenames = basenames;
@@ -284,7 +291,7 @@ function trivia3(pattern, options) {
     }
     return parsedPattern;
 }
-function trivia4and5(targetPath, pattern, matchPathEnds) {
+function trivia4and5(targetPath, pattern, matchPathEnds, options) {
     const usingPosixSep = sep === posix.sep;
     const nativePath = usingPosixSep ? targetPath : targetPath.replace(ALL_FORWARD_SLASHES, sep);
     const nativePathEnd = sep + nativePath;
@@ -292,34 +299,35 @@ function trivia4and5(targetPath, pattern, matchPathEnds) {
     let parsedPattern;
     if (matchPathEnds) {
         parsedPattern = function (path, basename) {
-            return typeof path === 'string' && ((path === nativePath || path.endsWith(nativePathEnd)) || !usingPosixSep && (path === targetPath || path.endsWith(targetPathEnd))) ? pattern : null;
+            return typeof path === 'string' && ((options.equals(path, nativePath) || options.endsWith(path, nativePathEnd)) ||
+                !usingPosixSep && (options.equals(path, targetPath) || options.endsWith(path, targetPathEnd))) ? pattern : null;
         };
     }
     else {
         parsedPattern = function (path, basename) {
-            return typeof path === 'string' && (path === nativePath || (!usingPosixSep && path === targetPath)) ? pattern : null;
+            return typeof path === 'string' && (options.equals(path, nativePath) || (!usingPosixSep && options.equals(path, targetPath))) ? pattern : null;
         };
     }
     parsedPattern.allPaths = [(matchPathEnds ? '*/' : './') + targetPath];
     return parsedPattern;
 }
-function toRegExp(pattern) {
+function toRegExp(pattern, options) {
     try {
-        const regExp = ( new RegExp(`^${parseRegExp(pattern)}$`));
+        const regExp = ( new RegExp(`^${parseRegExp(pattern)}$`, options.ignoreCase ? 'i' : undefined));
         return function (path) {
             regExp.lastIndex = 0;
             return typeof path === 'string' && regExp.test(path) ? pattern : null;
         };
     }
-    catch (error) {
+    catch {
         return NULL;
     }
 }
-function match(arg1, path, hasSibling) {
+function match(arg1, path, options) {
     if (!arg1 || typeof path !== 'string') {
         return false;
     }
-    return parse(arg1)(path, undefined, hasSibling);
+    return parse(arg1, options)(path);
 }
 function parse(arg1, options = {}) {
     if (!arg1) {
@@ -409,7 +417,7 @@ function parsedExpression(expression, options) {
                     base = basename(path);
                 }
                 if (!name) {
-                    name = base.substr(0, base.length - extname(path).length);
+                    name = base.substring(0, base.length - extname(path).length);
                 }
             }
             const result = parsedPattern(path, base, name, hasSibling);
@@ -510,7 +518,7 @@ function aggregateBasenameMatches(parsedPatterns, result) {
                     break;
                 }
             }
-            basename = path.substr(i);
+            basename = path.substring(i);
         }
         const index = basenames.indexOf(basename);
         return index !== -1 ? patterns[index] : null;

package/vscode/src/vs/base/common/history.d.ts

@@ -5,9 +5,9 @@ export interface IHistory<T> {
     add(t: T): this;
     has(t: T): boolean;
     clear(): void;
-    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: unknown): void;
     replace?(t: T[]): void;
-    onDidChange?: Event<string[]>;
+    readonly onDidChange?: Event<string[]>;
 }
 export declare class HistoryNavigator<T> implements INavigator<T> {
     private _history;

package/vscode/src/vs/base/common/htmlContent.d.ts

@@ -7,6 +7,8 @@ export interface IMarkdownString {
     readonly isTrusted?: boolean | MarkdownStringTrustedOptions;
     readonly supportThemeIcons?: boolean;
     readonly supportHtml?: boolean;
+    /** @internal */
+    readonly supportAlertSyntax?: boolean;
     readonly baseUri?: UriComponents;
     uris?: {
         [href: string]: UriComponents;
@@ -21,6 +23,7 @@ export declare class MarkdownString implements IMarkdownString {
     isTrusted?: boolean | MarkdownStringTrustedOptions;
     supportThemeIcons?: boolean;
     supportHtml?: boolean;
+    supportAlertSyntax?: boolean;
     baseUri?: URI;
     uris?: {
         [href: string]: UriComponents;
@@ -30,6 +33,7 @@ export declare class MarkdownString implements IMarkdownString {
         isTrusted?: boolean | MarkdownStringTrustedOptions;
         supportThemeIcons?: boolean;
         supportHtml?: boolean;
+        supportAlertSyntax?: boolean;
     });
     appendText(value: string, newlineStyle?: MarkdownStringTextNewlineStyle): MarkdownString;
     appendMarkdown(value: string): MarkdownString;

package/vscode/src/vs/base/common/htmlContent.js

@@ -27,11 +27,13 @@ class MarkdownString {
             this.isTrusted = isTrustedOrOptions;
             this.supportThemeIcons = false;
             this.supportHtml = false;
+            this.supportAlertSyntax = false;
         }
         else {
             this.isTrusted = isTrustedOrOptions.isTrusted ?? undefined;
             this.supportThemeIcons = isTrustedOrOptions.supportThemeIcons ?? false;
             this.supportHtml = isTrustedOrOptions.supportHtml ?? false;
+            this.supportAlertSyntax = isTrustedOrOptions.supportAlertSyntax ?? false;
         }
     }
     appendText(value, newlineStyle = MarkdownStringTextNewlineStyle.Paragraph) {
@@ -90,7 +92,8 @@ function isMarkdownString(thing) {
     else if (thing && typeof thing === 'object') {
         return typeof thing.value === 'string'
             && (typeof thing.isTrusted === 'boolean' || typeof thing.isTrusted === 'object' || thing.isTrusted === undefined)
-            && (typeof thing.supportThemeIcons === 'boolean' || thing.supportThemeIcons === undefined);
+            && (typeof thing.supportThemeIcons === 'boolean' || thing.supportThemeIcons === undefined)
+            && (typeof thing.supportAlertSyntax === 'boolean' || thing.supportAlertSyntax === undefined);
     }
     return false;
 }
@@ -106,6 +109,7 @@ function markdownStringEqual(a, b) {
             && a.isTrusted === b.isTrusted
             && a.supportThemeIcons === b.supportThemeIcons
             && a.supportHtml === b.supportHtml
+            && a.supportAlertSyntax === b.supportAlertSyntax
             && (a.baseUri === b.baseUri || !!a.baseUri && !!b.baseUri && isEqual(( URI.from(a.baseUri)), ( URI.from(b.baseUri))));
     }
 }

package/vscode/src/vs/base/common/jsonSchema.d.ts

@@ -88,31 +88,59 @@ export interface IJSONSchemaSnippet {
 }
 /**
  * Converts a basic JSON schema to a TypeScript type.
- *
- * TODO: only supports basic schemas. Doesn't support all JSON schema features.
  */
-export type SchemaToType<T> = T extends {
-    type: "string";
-} ? string : T extends {
-    type: "number";
-} ? number : T extends {
-    type: "boolean";
-} ? boolean : T extends {
-    type: "null";
-} ? null : T extends {
+export type TypeFromJsonSchema<T> = T extends {
+    enum: infer EnumValues;
+} ? UnionOf<EnumValues> : T extends {
     type: "object";
     properties: infer P;
+    required: infer RequiredList;
 } ? {
-    [K in keyof P]: SchemaToType<P[K]>;
-} : T extends {
+    [K in keyof P]: IsRequired<K, RequiredList> extends true ? TypeFromJsonSchema<P[K]> : TypeFromJsonSchema<P[K]> | undefined;
+} & AdditionalPropertiesType<T> : T extends {
+    type: "object";
+    properties: infer P;
+} ? {
+    [K in keyof P]: TypeFromJsonSchema<P[K]> | undefined;
+} & AdditionalPropertiesType<T> : T extends {
     type: "array";
-    items: infer I;
-} ? Array<SchemaToType<I>> : T extends {
+    items: infer Items;
+} ? Items extends [
+    ...infer R
+] ? {
+    [K in keyof R]: TypeFromJsonSchema<Items[K]>;
+} : Array<TypeFromJsonSchema<Items>> : T extends {
     oneOf: infer I;
-} ? MapSchemaToType<I> : never;
+} ? MapSchemaToType<I> : T extends {
+    anyOf: infer I;
+} ? MapSchemaToType<I> : T extends {
+    type: infer Type;
+} ? Type extends "string" | "number" | "integer" | "boolean" | "null" ? SchemaPrimitiveTypeNameToType<Type> : Type extends [
+    ...infer R
+] ? UnionOf<{
+    [K in keyof R]: SchemaPrimitiveTypeNameToType<R[K]>;
+}> : never : never;
+type SchemaPrimitiveTypeNameToType<T> = T extends "string" ? string : T extends "number" | "integer" ? number : T extends "boolean" ? boolean : T extends "null" ? null : never;
+type UnionOf<T> = T extends [
+    infer First,
+    ...infer Rest
+] ? First | UnionOf<Rest> : never;
+type IsRequired<K, RequiredList> = RequiredList extends [
+] ? false : RequiredList extends [
+    K,
+    ...infer _
+] ? true : RequiredList extends [
+    infer _,
+    ...infer R
+] ? IsRequired<K, R> : false;
+type AdditionalPropertiesType<Schema> = Schema extends {
+    additionalProperties: infer AP;
+} ? AP extends false ? {} : {
+    [key: string]: TypeFromJsonSchema<Schema["additionalProperties"]>;
+} : {};
 type MapSchemaToType<T> = T extends [
     infer First,
     ...infer Rest
-] ? SchemaToType<First> | MapSchemaToType<Rest> : never;
+] ? TypeFromJsonSchema<First> | MapSchemaToType<Rest> : never;
 export declare function getCompressedContent(schema: IJSONSchema): string;
 export {};