@codingame/monaco-vscode-api 2.2.1 → 3.0.0

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

@@ -100,6 +100,15 @@ function asPromise(callback) {
         }
     }));
 }
+function promiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = ( new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    }));
+    return { promise, resolve: resolve, reject: reject };
+}
 class Throttler {
     constructor() {
         this.isDisposed = false;
@@ -759,12 +768,7 @@ class TaskSequentializer {
     }
     queue(run) {
         if (!this._queued) {
-            let promiseResolve;
-            let promiseReject;
-            const promise = ( new Promise((resolve, reject) => {
-                promiseResolve = resolve;
-                promiseReject = reject;
-            }));
+            const { promise, resolve: promiseResolve, reject: promiseReject } = promiseWithResolvers();
             this._queued = {
                 run,
                 promise,
@@ -1125,4 +1129,4 @@ class AsyncIterableSource {
         this._emitFn(item);
     }
 }
-export { AbstractIdleValue, AsyncIterableObject, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableObject, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterable, createCancelablePromise, disposableTimeout, first, isThenable, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };
+export { AbstractIdleValue, AsyncIterableObject, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableObject, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterable, createCancelablePromise, disposableTimeout, first, isThenable, promiseWithResolvers, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };

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

@@ -556,6 +556,10 @@ declare const Codicon: {
     readonly gitStash: ThemeIcon;
     readonly gitStashApply: ThemeIcon;
     readonly gitStashPop: ThemeIcon;
+    readonly runAllCoverage: ThemeIcon;
+    readonly runCoverage: ThemeIcon;
+    readonly coverage: ThemeIcon;
+    readonly githubProject: ThemeIcon;
     readonly dialogError: ThemeIcon;
     readonly dialogWarning: ThemeIcon;
     readonly dialogInfo: ThemeIcon;

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

@@ -566,6 +566,10 @@ const Codicon = {
     gitStash: register('git-stash', 0xec26),
     gitStashApply: register('git-stash-apply', 0xec27),
     gitStashPop: register('git-stash-pop', 0xec28),
+    runAllCoverage: register('run-all-coverage', 0xec2d),
+    runCoverage: register('run-all-coverage', 0xec2c),
+    coverage: register('coverage', 0xec2e),
+    githubProject: register('github-project', 0xec2f),
     dialogError: register('dialog-error', 'error'),
     dialogWarning: register('dialog-warning', 'warning'),
     dialogInfo: register('dialog-info', 'info'),

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

@@ -381,6 +381,60 @@ function fromNow(date, appendAgoLabel, useFullTimeWords, disallowNow) {
         }
     }
 }
+function getDurationString(ms, useFullTimeWords) {
+    const seconds = Math.abs(ms / 1000);
+    if (seconds < 1) {
+        return useFullTimeWords
+            ? ( localizeWithPath('vs/base/common/date', 'duration.ms.full', '{0} milliseconds', ms))
+            : ( localizeWithPath('vs/base/common/date', 'duration.ms', '{0}ms', ms));
+    }
+    if (seconds < minute) {
+        return useFullTimeWords
+            ? ( localizeWithPath(
+            'vs/base/common/date',
+            'duration.s.full',
+            '{0} seconds',
+            Math.round(ms) / 1000
+        ))
+            : ( localizeWithPath('vs/base/common/date', 'duration.s', '{0}s', Math.round(ms) / 1000));
+    }
+    if (seconds < hour) {
+        return useFullTimeWords
+            ? ( localizeWithPath(
+            'vs/base/common/date',
+            'duration.m.full',
+            '{0} minutes',
+            Math.round(ms / (1000 * minute))
+        ))
+            : ( localizeWithPath(
+            'vs/base/common/date',
+            'duration.m',
+            '{0} mins',
+            Math.round(ms / (1000 * minute))
+        ));
+    }
+    if (seconds < day) {
+        return useFullTimeWords
+            ? ( localizeWithPath(
+            'vs/base/common/date',
+            'duration.h.full',
+            '{0} hours',
+            Math.round(ms / (1000 * hour))
+        ))
+            : ( localizeWithPath(
+            'vs/base/common/date',
+            'duration.h',
+            '{0} hrs',
+            Math.round(ms / (1000 * hour))
+        ));
+    }
+    return ( localizeWithPath(
+        'vs/base/common/date',
+        'duration.d',
+        '{0} days',
+        Math.round(ms / (1000 * day))
+    ));
+}
 function toLocalISOString(date) {
     return date.getFullYear() +
         '-' + String(date.getMonth() + 1).padStart(2, '0') +
@@ -391,4 +445,4 @@ function toLocalISOString(date) {
         '.' + (date.getMilliseconds() / 1000).toFixed(3).slice(2, 5) +
         'Z';
 }
-export { fromNow, toLocalISOString };
+export { fromNow, getDurationString, toLocalISOString };

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

@@ -834,13 +834,15 @@ class EventMultiplexer {
         e.listener = e.event(r => this.emitter.fire(r));
     }
     unhook(e) {
-        if (e.listener) {
-            e.listener.dispose();
-        }
+        e.listener?.dispose();
         e.listener = null;
     }
     dispose() {
         this.emitter.dispose();
+        for (const e of this.events) {
+            e.listener?.dispose();
+        }
+        this.events = [];
     }
 }
 class DynamicListEventMultiplexer {

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

@@ -204,7 +204,7 @@ function matchesCamelCase(word, camelCaseWord) {
         return null;
     }
     if (camelCaseWord.length > 60) {
-        return null;
+        camelCaseWord = camelCaseWord.substring(0, 60);
     }
     const analysis = analyzeCamelCaseWord(camelCaseWord);
     if (!isCamelCaseWord(analysis)) {

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

@@ -20,9 +20,10 @@ function registerGlobalHotReloadHandler() {
     }
     const g = globalThis;
     if (!g.$hotReload_applyNewExports) {
-        g.$hotReload_applyNewExports = oldExports => {
+        g.$hotReload_applyNewExports = args => {
+            const args2 = { config: { mode: undefined }, ...args };
             for (const h of hotReloadHandlers) {
-                const result = h(oldExports);
+                const result = h(args2);
                 if (result) {
                     return result;
                 }
@@ -34,8 +35,8 @@ function registerGlobalHotReloadHandler() {
 }
 let hotReloadHandlers = undefined;
 if (isHotReloadEnabled()) {
-    registerHotReloadHandler(({ oldExports, newSrc }) => {
-        if (newSrc.indexOf('/* ' + 'hot-reload:patch-prototype-methods */') === -1) {
+    registerHotReloadHandler(({ oldExports, newSrc, config }) => {
+        if (config.mode !== 'patch-prototype') {
             return undefined;
         }
         return newExports => {

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

@@ -30,6 +30,7 @@ var Schemas;
     Schemas.vscodeSettings = 'vscode-settings';
     Schemas.vscodeWorkspaceTrust = 'vscode-workspace-trust';
     Schemas.vscodeTerminal = 'vscode-terminal';
+    Schemas.vscodeChatCodeBlock = 'vscode-chat-code-block';
     Schemas.vscodeChatSesssion = 'vscode-chat-editor';
     Schemas.webviewPanel = 'webview-panel';
     Schemas.vscodeWebview = 'vscode-webview';
@@ -38,6 +39,8 @@ var Schemas;
     Schemas.tmp = 'tmp';
     Schemas.vsls = 'vsls';
     Schemas.vscodeSourceControl = 'vscode-scm';
+    Schemas.codeSetting = 'code-setting';
+    Schemas.codeFeature = 'code-feature';
 })(Schemas || (Schemas = {})));
 function matchesScheme(target, scheme) {
     if (URI.isUri(target)) {

package/vscode/src/vs/base/common/observableInternal/autorun.js

@@ -1,24 +1,21 @@
 import { assertFn } from '../assert.js';
 import { toDisposable, DisposableStore } from '../lifecycle.js';
-import { getFunctionName } from './base.js';
+import { DebugNameData } from './debugName.js';
 function autorun(fn) {
-    return ( new AutorunObserver(undefined, fn, undefined, undefined));
+    return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined, undefined));
 }
 function autorunOpts(options, fn) {
-    return ( new AutorunObserver(options.debugName, fn, undefined, undefined));
+    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, undefined, undefined));
 }
 function autorunHandleChanges(options, fn) {
-    return ( new AutorunObserver(
-        options.debugName,
-        fn,
-        options.createEmptyChangeSummary,
-        options.handleChange
-    ));
+    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.createEmptyChangeSummary, options.handleChange));
 }
 function autorunWithStore(fn) {
     const store = ( new DisposableStore());
     const disposable = autorunOpts({
-        debugName: () => getFunctionName(fn) || '(anonymous)',
+        owner: undefined,
+        debugName: undefined,
+        debugReferenceFn: fn,
     }, reader => {
         store.clear();
         fn(reader, store);
@@ -28,25 +25,21 @@ function autorunWithStore(fn) {
         store.dispose();
     });
 }
+function autorunDelta(observable, handler) {
+    let _lastValue;
+    return autorunOpts({ debugReferenceFn: handler }, (reader) => {
+        const newValue = observable.read(reader);
+        const lastValue = _lastValue;
+        _lastValue = newValue;
+        handler({ lastValue, newValue });
+    });
+}
 class AutorunObserver {
     get debugName() {
-        if (typeof this._debugName === 'string') {
-            return this._debugName;
-        }
-        if (typeof this._debugName === 'function') {
-            const name = this._debugName();
-            if (name !== undefined) {
-                return name;
-            }
-        }
-        const name = getFunctionName(this._runFn);
-        if (name !== undefined) {
-            return name;
-        }
-        return '(anonymous)';
+        return this._debugNameData.getDebugName(this) ?? '(anonymous)';
     }
-    constructor(_debugName, _runFn, createChangeSummary, _handleChange) {
-        this._debugName = _debugName;
+    constructor(_debugNameData, _runFn, createChangeSummary, _handleChange) {
+        this._debugNameData = _debugNameData;
         this._runFn = _runFn;
         this.createChangeSummary = createChangeSummary;
         this._handleChange = _handleChange;
@@ -146,13 +139,4 @@ class AutorunObserver {
 ( (function(autorun) {
     autorun.Observer = AutorunObserver;
 })(autorun || (autorun = {})));
-function autorunDelta(observable, handler) {
-    let _lastValue;
-    return autorunOpts({ debugName: () => getFunctionName(handler) }, (reader) => {
-        const newValue = observable.read(reader);
-        const lastValue = _lastValue;
-        _lastValue = newValue;
-        handler({ lastValue, newValue });
-    });
-}
 export { AutorunObserver, autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore };

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

@@ -1,3 +1,4 @@
+import { DebugNameData, getFunctionName } from './debugName.js';
 let _recomputeInitiallyAndOnChange;
 function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
     _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
@@ -143,86 +144,6 @@ class TransactionImpl {
         this.updatingObservers = null;
     }
 }
-const countPerName = ( new Map());
-const cachedDebugName = ( new WeakMap());
-function getDebugName(self, debugNameFn, fn, owner) {
-    const cached = cachedDebugName.get(self);
-    if (cached) {
-        return cached;
-    }
-    const dbgName = computeDebugName(self, debugNameFn, fn, owner);
-    if (dbgName) {
-        let count = countPerName.get(dbgName) ?? 0;
-        count++;
-        countPerName.set(dbgName, count);
-        const result = count === 1 ? dbgName : `${dbgName}#${count}`;
-        cachedDebugName.set(self, result);
-        return result;
-    }
-    return undefined;
-}
-function computeDebugName(self, debugNameFn, fn, owner) {
-    const cached = cachedDebugName.get(self);
-    if (cached) {
-        return cached;
-    }
-    const ownerStr = owner ? formatOwner(owner) + `.` : '';
-    let result;
-    if (debugNameFn !== undefined) {
-        if (typeof debugNameFn === 'function') {
-            result = debugNameFn();
-            if (result !== undefined) {
-                return ownerStr + result;
-            }
-        }
-        else {
-            return ownerStr + debugNameFn;
-        }
-    }
-    if (fn !== undefined) {
-        result = getFunctionName(fn);
-        if (result !== undefined) {
-            return ownerStr + result;
-        }
-    }
-    if (owner !== undefined) {
-        for (const key in owner) {
-            if (owner[key] === self) {
-                return ownerStr + key;
-            }
-        }
-    }
-    return undefined;
-}
-const countPerClassName = ( new Map());
-const ownerId = ( new WeakMap());
-function formatOwner(owner) {
-    const id = ownerId.get(owner);
-    if (id) {
-        return id;
-    }
-    const className = getClassName(owner);
-    let count = countPerClassName.get(className) ?? 0;
-    count++;
-    countPerClassName.set(className, count);
-    const result = count === 1 ? className : `${className}#${count}`;
-    ownerId.set(owner, result);
-    return result;
-}
-function getClassName(obj) {
-    const ctor = obj.constructor;
-    if (ctor) {
-        return ctor.name;
-    }
-    return 'Object';
-}
-function getFunctionName(fn) {
-    const fnSrc = ( fn.toString());
-    const regexp = /\/\*\*\s*@description\s*([^*]*)\*\//;
-    const match = regexp.exec(fnSrc);
-    const result = match ? match[1] : undefined;
-    return result?.trim();
-}
 function observableValue(nameOrOwner, initialValue) {
     if (typeof nameOrOwner === 'string') {
         return ( new ObservableValue(undefined, nameOrOwner, initialValue));
@@ -233,7 +154,7 @@ function observableValue(nameOrOwner, initialValue) {
 }
 class ObservableValue extends BaseObservable {
     get debugName() {
-        return getDebugName(this, this._debugName, undefined, this._owner) ?? 'ObservableValue';
+        return ( new DebugNameData(this._owner, this._debugName, undefined)).getDebugName(this) ?? 'ObservableValue';
     }
     constructor(_owner, _debugName, initialValue) {
         super();
@@ -294,4 +215,4 @@ class DisposableObservableValue extends ObservableValue {
         this._value?.dispose();
     }
 }
-export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, getDebugName, getFunctionName, globalTransaction, observableValue, subtransaction, transaction };
+export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction };

package/vscode/src/vs/base/common/observableInternal/debugName.js

@@ -0,0 +1,100 @@
+class DebugNameData {
+    constructor(owner, debugNameSource, referenceFn) {
+        this.owner = owner;
+        this.debugNameSource = debugNameSource;
+        this.referenceFn = referenceFn;
+    }
+    getDebugName(target) {
+        return getDebugName(target, this);
+    }
+}
+const countPerName = ( new Map());
+const cachedDebugName = ( new WeakMap());
+function getDebugName(target, data) {
+    const cached = cachedDebugName.get(target);
+    if (cached) {
+        return cached;
+    }
+    const dbgName = computeDebugName(target, data);
+    if (dbgName) {
+        let count = countPerName.get(dbgName) ?? 0;
+        count++;
+        countPerName.set(dbgName, count);
+        const result = count === 1 ? dbgName : `${dbgName}#${count}`;
+        cachedDebugName.set(target, result);
+        return result;
+    }
+    return undefined;
+}
+function computeDebugName(self, data) {
+    const cached = cachedDebugName.get(self);
+    if (cached) {
+        return cached;
+    }
+    const ownerStr = data.owner ? formatOwner(data.owner) + `.` : '';
+    let result;
+    const debugNameSource = data.debugNameSource;
+    if (debugNameSource !== undefined) {
+        if (typeof debugNameSource === 'function') {
+            result = debugNameSource();
+            if (result !== undefined) {
+                return ownerStr + result;
+            }
+        }
+        else {
+            return ownerStr + debugNameSource;
+        }
+    }
+    const referenceFn = data.referenceFn;
+    if (referenceFn !== undefined) {
+        result = getFunctionName(referenceFn);
+        if (result !== undefined) {
+            return ownerStr + result;
+        }
+    }
+    if (data.owner !== undefined) {
+        const key = findKey(data.owner, self);
+        if (key !== undefined) {
+            return ownerStr + key;
+        }
+    }
+    return undefined;
+}
+function findKey(obj, value) {
+    for (const key in obj) {
+        if (obj[key] === value) {
+            return key;
+        }
+    }
+    return undefined;
+}
+const countPerClassName = ( new Map());
+const ownerId = ( new WeakMap());
+function formatOwner(owner) {
+    const id = ownerId.get(owner);
+    if (id) {
+        return id;
+    }
+    const className = getClassName(owner);
+    let count = countPerClassName.get(className) ?? 0;
+    count++;
+    countPerClassName.set(className, count);
+    const result = count === 1 ? className : `${className}#${count}`;
+    ownerId.set(owner, result);
+    return result;
+}
+function getClassName(obj) {
+    const ctor = obj.constructor;
+    if (ctor) {
+        return ctor.name;
+    }
+    return 'Object';
+}
+function getFunctionName(fn) {
+    const fnSrc = ( fn.toString());
+    const regexp = /\/\*\*\s*@description\s*([^*]*)\*\//;
+    const match = regexp.exec(fnSrc);
+    const result = match ? match[1] : undefined;
+    return result?.trim();
+}
+export { DebugNameData, getDebugName, getFunctionName };

package/vscode/src/vs/base/common/observableInternal/derived.js

@@ -1,50 +1,20 @@
 import { assertFn } from '../assert.js';
 import { DisposableStore } from '../lifecycle.js';
-import { getFunctionName, BaseObservable, getDebugName, _setDerivedOpts } from './base.js';
+import { BaseObservable, _setDerivedOpts } from './base.js';
+import { DebugNameData } from './debugName.js';
 const defaultEqualityComparer = (a, b) => a === b;
 function derived(computeFnOrOwner, computeFn) {
     if (computeFn !== undefined) {
-        return ( new Derived(
-            computeFnOrOwner,
-            undefined,
-            computeFn,
-            undefined,
-            undefined,
-            undefined,
-            defaultEqualityComparer
-        ));
-    }
-    return ( new Derived(
-        undefined,
-        undefined,
-        computeFnOrOwner,
-        undefined,
-        undefined,
-        undefined,
-        defaultEqualityComparer
-    ));
+        return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, undefined, defaultEqualityComparer));
+    }
+    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, undefined, defaultEqualityComparer));
 }
 function derivedOpts(options, computeFn) {
-    return ( new Derived(
-        options.owner,
-        options.debugName,
-        computeFn,
-        undefined,
-        undefined,
-        options.onLastObserverRemoved,
-        options.equalityComparer ?? defaultEqualityComparer
-    ));
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn)), computeFn, undefined, undefined, options.onLastObserverRemoved, options.equalityComparer ?? defaultEqualityComparer));
 }
+_setDerivedOpts(derivedOpts);
 function derivedHandleChanges(options, computeFn) {
-    return ( new Derived(
-        options.owner,
-        options.debugName,
-        computeFn,
-        options.createEmptyChangeSummary,
-        options.handleChange,
-        undefined,
-        options.equalityComparer ?? defaultEqualityComparer
-    ));
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, undefined)), computeFn, options.createEmptyChangeSummary, options.handleChange, undefined, options.equalityComparer ?? defaultEqualityComparer));
 }
 function derivedWithStore(computeFnOrOwner, computeFnOrUndefined) {
     let computeFn;
@@ -58,7 +28,7 @@ function derivedWithStore(computeFnOrOwner, computeFnOrUndefined) {
         computeFn = computeFnOrUndefined;
     }
     const store = ( new DisposableStore());
-    return ( new Derived(owner, (() => getFunctionName(computeFn) ?? '(anonymous)'), r => {
+    return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
         store.clear();
         return computeFn(r, store);
     }, undefined, undefined, () => store.dispose(), defaultEqualityComparer));
@@ -75,7 +45,7 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
         computeFn = computeFnOrUndefined;
     }
     const store = ( new DisposableStore());
-    return ( new Derived(owner, (() => getFunctionName(computeFn) ?? '(anonymous)'), r => {
+    return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
         store.clear();
         const result = computeFn(r);
         if (result) {
@@ -84,15 +54,13 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
         return result;
     }, undefined, undefined, () => store.dispose(), defaultEqualityComparer));
 }
-_setDerivedOpts(derivedOpts);
 class Derived extends BaseObservable {
     get debugName() {
-        return getDebugName(this, this._debugName, this._computeFn, this._owner) ?? '(anonymous)';
+        return this._debugNameData.getDebugName(this) ?? '(anonymous)';
     }
-    constructor(_owner, _debugName, _computeFn, createChangeSummary, _handleChange, _handleLastObserverRemoved = undefined, _equalityComparator) {
+    constructor(_debugNameData, _computeFn, createChangeSummary, _handleChange, _handleLastObserverRemoved = undefined, _equalityComparator) {
         super();
-        this._owner = _owner;
-        this._debugName = _debugName;
+        this._debugNameData = _debugNameData;
         this._computeFn = _computeFn;
         this.createChangeSummary = createChangeSummary;
         this._handleChange = _handleChange;
@@ -245,4 +213,4 @@ class Derived extends BaseObservable {
         }
     }
 }
-export { Derived, derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithStore };
+export { Derived, defaultEqualityComparer, derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithStore };