@codingame/monaco-vscode-api 1.69.5 → 1.69.8

package/dist/contextkey.js

@@ -1,4 +1,143 @@
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { isMacintosh, isLinux, isWindows, isWeb, isEdge, isFirefox, isChrome, isSafari } from 'monaco-editor/esm/vs/base/common/platform.js';
+function sortedDiff(before, after, compare) {
+    const result = [];
+    function pushSplice(start, deleteCount, toInsert) {
+        if (deleteCount === 0 && toInsert.length === 0) {
+            return;
+        }
+        const latest = result[result.length - 1];
+        if (latest && latest.start + latest.deleteCount === start) {
+            latest.deleteCount += deleteCount;
+            latest.toInsert.push(...toInsert);
+        }
+        else {
+            result.push({ start, deleteCount, toInsert });
+        }
+    }
+    let beforeIdx = 0;
+    let afterIdx = 0;
+    while (true) {
+        if (beforeIdx === before.length) {
+            pushSplice(beforeIdx, 0, after.slice(afterIdx));
+            break;
+        }
+        if (afterIdx === after.length) {
+            pushSplice(beforeIdx, before.length - beforeIdx, []);
+            break;
+        }
+        const beforeElement = before[beforeIdx];
+        const afterElement = after[afterIdx];
+        const n = compare(beforeElement, afterElement);
+        if (n === 0) {
+            beforeIdx += 1;
+            afterIdx += 1;
+        }
+        else if (n < 0) {
+            pushSplice(beforeIdx, 1, []);
+            beforeIdx += 1;
+        }
+        else if (n > 0) {
+            pushSplice(beforeIdx, 0, [afterElement]);
+            afterIdx += 1;
+        }
+    }
+    return result;
+}
+function delta(before, after, compare) {
+    const splices = sortedDiff(before, after, compare);
+    const removed = [];
+    const added = [];
+    for (const splice of splices) {
+        removed.push(...before.slice(splice.start, splice.start + splice.deleteCount));
+        added.push(...splice.toInsert);
+    }
+    return { removed, added };
+}
+function coalesceInPlace(array) {
+    let to = 0;
+    for (let i = 0; i < array.length; i++) {
+        if (!!array[i]) {
+            array[to] = array[i];
+            to += 1;
+        }
+    }
+    array.length = to;
+}
+function flatten(arr) {
+    return [].concat(...arr);
+}
+function index(array, indexer, mapper) {
+    return array.reduce((r, t) => {
+        r[indexer(t)] = mapper ? mapper(t) : t;
+        return r;
+    }, Object.create(null));
+}
+function insert(array, element) {
+    array.push(element);
+    return () => remove(array, element);
+}
+function remove(array, element) {
+    const index = array.indexOf(element);
+    if (index > -1) {
+        array.splice(index, 1);
+        return element;
+    }
+    return undefined;
+}
+function shuffle(array, _seed) {
+    let rand;
+    if (typeof _seed === 'number') {
+        let seed = _seed;
+        rand = () => {
+            const x = Math.sin(seed++) * 179426549;
+            return x - Math.floor(x);
+        };
+    }
+    else {
+        rand = Math.random;
+    }
+    for (let i = array.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(rand() * (i + 1));
+        const temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+}
+function mapArrayOrNot(items, fn) {
+    return Array.isArray(items) ?
+        items.map(fn) :
+        fn(items);
+}
+var NeverShowAgainScope;
+( (function(NeverShowAgainScope) {
+    NeverShowAgainScope[NeverShowAgainScope["WORKSPACE"] = 0] = "WORKSPACE";
+    NeverShowAgainScope[NeverShowAgainScope["PROFILE"] = 1] = "PROFILE";
+    NeverShowAgainScope[NeverShowAgainScope["APPLICATION"] = 2] = "APPLICATION";
+})(NeverShowAgainScope || (NeverShowAgainScope = {})));
+var NotificationsFilter;
+( (function(NotificationsFilter) {
+    NotificationsFilter[NotificationsFilter["OFF"] = 0] = "OFF";
+    NotificationsFilter[NotificationsFilter["SILENT"] = 1] = "SILENT";
+    NotificationsFilter[NotificationsFilter["ERROR"] = 2] = "ERROR";
+})(NotificationsFilter || (NotificationsFilter = {})));
+class NoOpNotification {
+    constructor() {
+        this.progress = ( new NoOpProgress());
+        this.onDidClose = Event.None;
+        this.onDidChangeVisibility = Event.None;
+    }
+    updateSeverity(severity) { }
+    updateMessage(message) { }
+    updateActions(actions) { }
+    close() { }
+}
+class NoOpProgress {
+    infinite() { }
+    done() { }
+    total(value) { }
+    worked(value) { }
+}
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -384,4 +523,4 @@ function cmp2(key1, value1, key2, value2) {
     }
     return 0;
 }
-export { ContextKeyExprType as C, RawContextKey as R, __decorate as _, __param as a, __classPrivateFieldSet as b, __classPrivateFieldGet as c };
+export { ContextKeyExprType as C, NoOpNotification as N, RawContextKey as R, __classPrivateFieldSet as _, __classPrivateFieldGet as a, __decorate as b, coalesceInPlace as c, __param as d, delta as e, NotificationsFilter as f, flatten as g, NeverShowAgainScope as h, insert as i, index as j, mapArrayOrNot as m, shuffle as s };

package/dist/dialogs.js

@@ -1,9 +1,10 @@
-import { E as Emitter } from './missing-services.js';
+import { E as Emitter } from './polyfill.js';
+import './missing-services.js';
 import { g as getServiceOverride$1, D as DialogHandlerContribution } from './layout.js';
-import { _ as __decorate, a as __param } from './contextkey.js';
+import { b as __decorate, d as __param } from './contextkey.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
-import { g as IWorkbenchEnvironmentService } from './services2.js';
+import { e as IWorkbenchEnvironmentService } from './services2.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { o as onServicesInitialized } from './tools.js';
 import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
@@ -12,13 +13,13 @@ class DialogsModel extends Disposable {
     constructor() {
         super(...arguments);
         this.dialogs = [];
-        this._onWillShowDialog = this._register(( (new Emitter())));
+        this._onWillShowDialog = this._register(( new Emitter()));
         this.onWillShowDialog = this._onWillShowDialog.event;
-        this._onDidShowDialog = this._register(( (new Emitter())));
+        this._onDidShowDialog = this._register(( new Emitter()));
         this.onDidShowDialog = this._onDidShowDialog.event;
     }
     show(dialog) {
-        const promise = ( (new DeferredPromise()));
+        const promise = ( new DeferredPromise());
         const item = {
             args: dialog,
             close: result => {
@@ -40,7 +41,7 @@ let DialogService = class DialogService extends Disposable {
         super();
         this.environmentService = environmentService;
         this.logService = logService;
-        this.model = this._register(( (new DialogsModel())));
+        this.model = this._register(( new DialogsModel()));
         this.onWillShowDialog = this.model.onWillShowDialog;
         this.onDidShowDialog = this.model.onDidShowDialog;
     }
@@ -80,17 +81,17 @@ let DialogService = class DialogService extends Disposable {
         await handle.result;
     }
 };
-DialogService = ( (__decorate([
-    ( (__param(0, IWorkbenchEnvironmentService))),
-    ( (__param(1, ILogService)))
-], DialogService)));
+DialogService = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, ILogService))
+], DialogService));
 function initialize(instantiationService) {
     instantiationService.createInstance(DialogHandlerContribution);
 }
 function getServiceOverride(container) {
     onServicesInitialized(initialize);
     return {
-        [( IDialogService.toString())]: new SyncDescriptor(DialogService),
+        [IDialogService.toString()]: new SyncDescriptor(DialogService),
         ...getServiceOverride$1(container)
     };
 }