npm - @codingame/monaco-vscode-api - Versions diffs - 3.2.3 → 4.1.0 - Mend

@codingame/monaco-vscode-api 3.2.3 → 4.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1672) hide show

package/vscode/src/vs/workbench/services/storage/browser/storageService.js ADDED Viewed

@@ -0,0 +1,290 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { BroadcastDataChannel } from '../../../../base/browser/broadcast.js';
+import { isSafari } from '../../../../base/browser/browser.js';
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { IndexedDB } from '../../../../base/browser/indexedDB.js';
+import { DeferredPromise, Promises } from '../../../../base/common/async.js';
+import { toErrorMessage } from '../../../../base/common/errorMessage.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { DisposableStore, Disposable } from '../../../../base/common/lifecycle.js';
+import { assertIsDefined } from '../../../../base/common/types.js';
+import { Storage, isStorageItemsChangeEvent, InMemoryStorageDatabase } from '../../../../base/parts/storage/common/storage.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { AbstractStorageService, isProfileUsingDefaultStorage, IS_NEW_KEY } from '../../../../platform/storage/common/storage.js';
+import { isUserDataProfile } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+var BrowserStorageService_1;
+let BrowserStorageService = class BrowserStorageService extends AbstractStorageService {
+    static { BrowserStorageService_1 = this; }
+    static { this.BROWSER_DEFAULT_FLUSH_INTERVAL = 5 * 1000; }
+    get hasPendingUpdate() {
+        return Boolean(this.applicationStorageDatabase?.hasPendingUpdate ||
+            this.profileStorageDatabase?.hasPendingUpdate ||
+            this.workspaceStorageDatabase?.hasPendingUpdate);
+    }
+    constructor(workspace, userDataProfileService, logService) {
+        super({ flushInterval: BrowserStorageService_1.BROWSER_DEFAULT_FLUSH_INTERVAL });
+        this.workspace = workspace;
+        this.userDataProfileService = userDataProfileService;
+        this.logService = logService;
+        this.applicationStoragePromise = ( new DeferredPromise());
+        this.profileStorageProfile = this.userDataProfileService.currentProfile;
+        this.profileStorageDisposables = this._register(( new DisposableStore()));
+        this.workspaceStorageDisposables = this._register(( new DisposableStore()));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(e => e.join(this.switchToProfile(e.profile))));
+    }
+    async doInitialize() {
+        await Promises.settled([
+            this.createApplicationStorage(),
+            this.createProfileStorage(this.profileStorageProfile),
+            this.createWorkspaceStorage()
+        ]);
+    }
+    async createApplicationStorage() {
+        const applicationStorageIndexedDB = await IndexedDBStorageDatabase.createApplicationStorage(this.logService);
+        this.applicationStorageDatabase = this._register(applicationStorageIndexedDB);
+        this.applicationStorage = this._register(( new Storage(this.applicationStorageDatabase)));
+        this._register(this.applicationStorage.onDidChangeStorage(e => this.emitDidChangeValue(-1 , e)));
+        await this.applicationStorage.init();
+        this.updateIsNew(this.applicationStorage);
+        this.applicationStoragePromise.complete({ indexedDb: applicationStorageIndexedDB, storage: this.applicationStorage });
+    }
+    async createProfileStorage(profile) {
+        this.profileStorageDisposables.clear();
+        this.profileStorageProfile = profile;
+        if (isProfileUsingDefaultStorage(this.profileStorageProfile)) {
+            const { indexedDb: applicationStorageIndexedDB, storage: applicationStorage } = await this.applicationStoragePromise.p;
+            this.profileStorageDatabase = applicationStorageIndexedDB;
+            this.profileStorage = applicationStorage;
+            this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(0 , e)));
+        }
+        else {
+            const profileStorageIndexedDB = await IndexedDBStorageDatabase.createProfileStorage(this.profileStorageProfile, this.logService);
+            this.profileStorageDatabase = this.profileStorageDisposables.add(profileStorageIndexedDB);
+            this.profileStorage = this.profileStorageDisposables.add(( new Storage(this.profileStorageDatabase)));
+            this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(0 , e)));
+            await this.profileStorage.init();
+            this.updateIsNew(this.profileStorage);
+        }
+    }
+    async createWorkspaceStorage() {
+        this.workspaceStorageDisposables.clear();
+        const workspaceStorageIndexedDB = await IndexedDBStorageDatabase.createWorkspaceStorage(this.workspace.id, this.logService);
+        this.workspaceStorageDatabase = this.workspaceStorageDisposables.add(workspaceStorageIndexedDB);
+        this.workspaceStorage = this.workspaceStorageDisposables.add(( new Storage(this.workspaceStorageDatabase)));
+        this.workspaceStorageDisposables.add(this.workspaceStorage.onDidChangeStorage(e => this.emitDidChangeValue(1 , e)));
+        await this.workspaceStorage.init();
+        this.updateIsNew(this.workspaceStorage);
+    }
+    updateIsNew(storage) {
+        const firstOpen = storage.getBoolean(IS_NEW_KEY);
+        if (firstOpen === undefined) {
+            storage.set(IS_NEW_KEY, true);
+        }
+        else if (firstOpen) {
+            storage.set(IS_NEW_KEY, false);
+        }
+    }
+    getStorage(scope) {
+        switch (scope) {
+            case -1 :
+                return this.applicationStorage;
+            case 0 :
+                return this.profileStorage;
+            default:
+                return this.workspaceStorage;
+        }
+    }
+    getLogDetails(scope) {
+        switch (scope) {
+            case -1 :
+                return this.applicationStorageDatabase?.name;
+            case 0 :
+                return this.profileStorageDatabase?.name;
+            default:
+                return this.workspaceStorageDatabase?.name;
+        }
+    }
+    async switchToProfile(toProfile) {
+        if (!this.canSwitchProfile(this.profileStorageProfile, toProfile)) {
+            return;
+        }
+        const oldProfileStorage = assertIsDefined(this.profileStorage);
+        const oldItems = oldProfileStorage.items;
+        if (oldProfileStorage !== this.applicationStorage) {
+            await oldProfileStorage.close();
+        }
+        await this.createProfileStorage(toProfile);
+        this.switchData(oldItems, assertIsDefined(this.profileStorage), 0 );
+    }
+    async switchToWorkspace(toWorkspace, preserveData) {
+        const oldWorkspaceStorage = assertIsDefined(this.workspaceStorage);
+        const oldItems = preserveData ? oldWorkspaceStorage.items : ( new Map());
+        await oldWorkspaceStorage.close();
+        this.workspace = toWorkspace;
+        await this.createWorkspaceStorage();
+        this.switchData(oldItems, assertIsDefined(this.workspaceStorage), 1 );
+    }
+    shouldFlushWhenIdle() {
+        return getActiveWindow().document.hasFocus() && !this.hasPendingUpdate;
+    }
+    close() {
+        if (isSafari) {
+            this.applicationStorage?.close();
+            this.profileStorageDatabase?.close();
+            this.workspaceStorageDatabase?.close();
+        }
+        this.dispose();
+    }
+    async clear() {
+        for (const scope of [-1 , 0 , 1 ]) {
+            for (const target of [0 , 1 ]) {
+                for (const key of ( this.keys(scope, target))) {
+                    this.remove(key, scope);
+                }
+            }
+            await this.getStorage(scope)?.whenFlushed();
+        }
+        await Promises.settled([
+            this.applicationStorageDatabase?.clear() ?? Promise.resolve(),
+            this.profileStorageDatabase?.clear() ?? Promise.resolve(),
+            this.workspaceStorageDatabase?.clear() ?? Promise.resolve()
+        ]);
+    }
+    hasScope(scope) {
+        if (isUserDataProfile(scope)) {
+            return this.profileStorageProfile.id === scope.id;
+        }
+        return this.workspace.id === scope.id;
+    }
+};
+BrowserStorageService = BrowserStorageService_1 = ( __decorate([
+    ( __param(2, ILogService))
+], BrowserStorageService));
+class InMemoryIndexedDBStorageDatabase extends InMemoryStorageDatabase {
+    constructor() {
+        super(...arguments);
+        this.hasPendingUpdate = false;
+        this.name = 'in-memory-indexedb-storage';
+    }
+    async clear() {
+        (await this.getItems()).clear();
+    }
+    dispose() {
+    }
+}
+class IndexedDBStorageDatabase extends Disposable {
+    static async createApplicationStorage(logService) {
+        return IndexedDBStorageDatabase.create({ id: 'global', broadcastChanges: true }, logService);
+    }
+    static async createProfileStorage(profile, logService) {
+        return IndexedDBStorageDatabase.create({ id: `global-${profile.id}`, broadcastChanges: true }, logService);
+    }
+    static async createWorkspaceStorage(workspaceId, logService) {
+        return IndexedDBStorageDatabase.create({ id: workspaceId }, logService);
+    }
+    static async create(options, logService) {
+        try {
+            const database = ( new IndexedDBStorageDatabase(options, logService));
+            await database.whenConnected;
+            return database;
+        }
+        catch (error) {
+            logService.error(`[IndexedDB Storage ${options.id}] create(): ${toErrorMessage(error, true)}`);
+            return ( new InMemoryIndexedDBStorageDatabase());
+        }
+    }
+    static { this.STORAGE_DATABASE_PREFIX = 'vscode-web-state-db-'; }
+    static { this.STORAGE_OBJECT_STORE = 'ItemTable'; }
+    get hasPendingUpdate() { return !!this.pendingUpdate; }
+    constructor(options, logService) {
+        super();
+        this.logService = logService;
+        this._onDidChangeItemsExternal = this._register(( new Emitter()));
+        this.onDidChangeItemsExternal = this._onDidChangeItemsExternal.event;
+        this.pendingUpdate = undefined;
+        this.name = `${IndexedDBStorageDatabase.STORAGE_DATABASE_PREFIX}${options.id}`;
+        this.broadcastChannel = options.broadcastChanges ? this._register(( new BroadcastDataChannel(this.name))) : undefined;
+        this.whenConnected = this.connect();
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (this.broadcastChannel) {
+            this._register(this.broadcastChannel.onDidReceiveData(data => {
+                if (isStorageItemsChangeEvent(data)) {
+                    this._onDidChangeItemsExternal.fire(data);
+                }
+            }));
+        }
+    }
+    async connect() {
+        try {
+            return await IndexedDB.create(this.name, undefined, [IndexedDBStorageDatabase.STORAGE_OBJECT_STORE]);
+        }
+        catch (error) {
+            this.logService.error(`[IndexedDB Storage ${this.name}] connect() error: ${toErrorMessage(error)}`);
+            throw error;
+        }
+    }
+    async getItems() {
+        const db = await this.whenConnected;
+        function isValid(value) {
+            return typeof value === 'string';
+        }
+        return db.getKeyValues(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, isValid);
+    }
+    async updateItems(request) {
+        let didUpdate = false;
+        this.pendingUpdate = this.doUpdateItems(request);
+        try {
+            didUpdate = await this.pendingUpdate;
+        }
+        finally {
+            this.pendingUpdate = undefined;
+        }
+        if (this.broadcastChannel && didUpdate) {
+            const event = {
+                changed: request.insert,
+                deleted: request.delete
+            };
+            this.broadcastChannel.postData(event);
+        }
+    }
+    async doUpdateItems(request) {
+        const toInsert = request.insert;
+        const toDelete = request.delete;
+        if ((!toInsert && !toDelete) || (toInsert?.size === 0 && toDelete?.size === 0)) {
+            return false;
+        }
+        const db = await this.whenConnected;
+        await db.runInTransaction(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, 'readwrite', objectStore => {
+            const requests = [];
+            if (toInsert) {
+                for (const [key, value] of toInsert) {
+                    requests.push(objectStore.put(value, key));
+                }
+            }
+            if (toDelete) {
+                for (const key of toDelete) {
+                    requests.push(objectStore.delete(key));
+                }
+            }
+            return requests;
+        });
+        return true;
+    }
+    async optimize() {
+    }
+    async close() {
+        const db = await this.whenConnected;
+        await this.pendingUpdate;
+        return db.close();
+    }
+    async clear() {
+        const db = await this.whenConnected;
+        await db.runInTransaction(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, 'readwrite', objectStore => objectStore.clear());
+    }
+}
+export { BrowserStorageService, IndexedDBStorageDatabase };

package/vscode/src/vs/workbench/services/suggest/browser/media/suggest.css.js ADDED Viewed

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".workbench-suggest-widget{display:flex;flex-direction:column;left:0;position:absolute;top:0;width:430px;z-index:40}.workbench-suggest-widget.message{align-items:center;flex-direction:row}.monaco-workbench .workbench-suggest-details,.workbench-suggest-widget{background-color:var(--vscode-editorSuggestWidget-background);border-color:var(--vscode-editorSuggestWidget-border);border-style:solid;border-width:1px;flex:0 1 auto;width:100%}.monaco-workbench.hc-black .workbench-suggest-details,.monaco-workbench.hc-black .workbench-suggest-widget,.monaco-workbench.hc-light .workbench-suggest-details,.monaco-workbench.hc-light .workbench-suggest-widget{border-width:2px}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar{display:flex}.monaco-workbench .workbench-suggest-widget .suggest-status-bar .left{padding-right:8px}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-label{color:var(--vscode-editorSuggestWidgetStatus-foreground)}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label{margin-right:0}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label:after{content:\", \";margin-right:.3em}.monaco-workbench .workbench-suggest-widget.with-status-bar .monaco-list .monaco-list-row.focused.string-label>.contents>.main>.right>.readMore,.monaco-workbench .workbench-suggest-widget.with-status-bar .monaco-list .monaco-list-row>.contents>.main>.right>.readMore{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row{background-position:2px 2px;background-repeat:no-repeat;-mox-box-sizing:border-box;box-sizing:border-box;cursor:pointer;display:flex;padding-right:10px;touch-action:none;white-space:nowrap}.workbench-suggest-widget .monaco-list .monaco-list-row.focused{color:var(--vscode-editorSuggestWidget-selectedForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row.focused .codicon{color:var(--vscode-editorSuggestWidget-selectedIconForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents{flex:1;height:100%;overflow:hidden;padding-left:2px}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main{display:flex;justify-content:space-between;overflow:hidden;text-overflow:ellipsis;white-space:pre}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left,.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right{display:flex}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.focused)>.contents>.main .monaco-icon-label{color:var(--vscode-editorSuggestWidget-foreground)}.workbench-suggest-widget:not(.frozen) .monaco-highlighted-label .highlight{font-weight:700}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main .monaco-highlighted-label .highlight{color:var(--vscode-editorSuggestWidget-highlightForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row.focused>.contents>.main .monaco-highlighted-label .highlight{color:var(--vscode-editorSuggestWidget-focusHighlightForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated{opacity:.66;text-decoration:unset}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated>.monaco-icon-label-container>.monaco-icon-name-container{text-decoration:line-through}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label:before{height:100%}.workbench-suggest-widget .monaco-list .monaco-list-row .icon{background-position:50%;background-repeat:no-repeat;background-size:80%;display:block;height:16px;margin-left:2px;width:16px}.workbench-suggest-widget .monaco-list .monaco-list-row .icon.hide{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row .suggest-icon{align-items:center;display:flex;margin-right:4px}.workbench-suggest-widget.no-icons .monaco-list .monaco-list-row .icon,.workbench-suggest-widget.no-icons .monaco-list .monaco-list-row .suggest-icon:before{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row .icon.customcolor .colorspan{border:.1em solid #000;display:inline-block;height:.7em;margin:0 0 0 .3em;width:.7em}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{opacity:.7}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.signature-label{opacity:.6;overflow:hidden;text-overflow:ellipsis}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.qualifier-label{align-self:center;font-size:85%;line-height:normal;margin-left:12px;opacity:.4;overflow:hidden;text-overflow:ellipsis}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{font-size:85%;margin-left:1.1em;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label>.monaco-tokenized-source{display:inline}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.right>.details-label,.workbench-suggest-widget.docs-side .monaco-list .monaco-list-row.focused:not(.string-label)>.contents>.main>.right>.details-label,.workbench-suggest-widget:not(.shows-details) .monaco-list .monaco-list-row.focused>.contents>.main>.right>.details-label{display:inline}.workbench-suggest-widget:not(.docs-side) .monaco-list .monaco-list-row.focused:hover>.contents>.main>.right.can-expand-details>.details-label{width:calc(100% - 26px)}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left{flex-grow:1;flex-shrink:1;overflow:hidden}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.monaco-icon-label{flex-shrink:0}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.left>.monaco-icon-label{max-width:100%}.workbench-suggest-widget .monaco-list .monaco-list-row.string-label>.contents>.main>.left>.monaco-icon-label{flex-shrink:1}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right{flex-shrink:4;max-width:70%;overflow:hidden}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore{display:inline-block;height:18px;position:absolute;right:10px;visibility:hidden;width:18px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/services/suggest/browser/simpleCompletionItem.js ADDED Viewed

@@ -0,0 +1,9 @@
+import { FuzzyScore } from '../../../../base/common/filters.js';
+class SimpleCompletionItem {
+    constructor(completion) {
+        this.completion = completion;
+        this.score = FuzzyScore.Default;
+        this.labelLow = this.completion.label.toLowerCase();
+    }
+}
+export { SimpleCompletionItem };

package/vscode/src/vs/workbench/services/suggest/browser/simpleCompletionModel.js ADDED Viewed

@@ -0,0 +1,97 @@
+import { quickSelect } from '../../../../base/common/arrays.js';
+import { FuzzyScoreOptions, FuzzyScore, fuzzyScore, fuzzyScoreGracefulAggressive } from '../../../../base/common/filters.js';
+class LineContext {
+    constructor(leadingLineContent, characterCountDelta) {
+        this.leadingLineContent = leadingLineContent;
+        this.characterCountDelta = characterCountDelta;
+    }
+}
+class SimpleCompletionModel {
+    constructor(_items, _lineContext, replacementIndex, replacementLength) {
+        this._items = _items;
+        this._lineContext = _lineContext;
+        this.replacementIndex = replacementIndex;
+        this.replacementLength = replacementLength;
+        this._refilterKind = 1 ;
+        this._fuzzyScoreOptions = FuzzyScoreOptions.default;
+        this._options = {};
+    }
+    get items() {
+        this._ensureCachedState();
+        return this._filteredItems;
+    }
+    get stats() {
+        this._ensureCachedState();
+        return this._stats;
+    }
+    get lineContext() {
+        return this._lineContext;
+    }
+    set lineContext(value) {
+        if (this._lineContext.leadingLineContent !== value.leadingLineContent
+            || this._lineContext.characterCountDelta !== value.characterCountDelta) {
+            this._refilterKind = this._lineContext.characterCountDelta < value.characterCountDelta && this._filteredItems ? 2  : 1 ;
+            this._lineContext = value;
+        }
+    }
+    _ensureCachedState() {
+        if (this._refilterKind !== 0 ) {
+            this._createCachedState();
+        }
+    }
+    _createCachedState() {
+        const labelLengths = [];
+        const { leadingLineContent, characterCountDelta } = this._lineContext;
+        let word = '';
+        let wordLow = '';
+        const source = this._refilterKind === 1  ? this._items : this._filteredItems;
+        const target = [];
+        const scoreFn = (!this._options.filterGraceful || source.length > 2000) ? fuzzyScore : fuzzyScoreGracefulAggressive;
+        for (let i = 0; i < source.length; i++) {
+            const item = source[i];
+            const overwriteBefore = this.replacementLength;
+            const wordLen = overwriteBefore + characterCountDelta;
+            if (word.length !== wordLen) {
+                word = wordLen === 0 ? '' : leadingLineContent.slice(-wordLen);
+                wordLow = word.toLowerCase();
+            }
+            item.word = word;
+            if (wordLen === 0) {
+                item.score = FuzzyScore.Default;
+            }
+            else {
+                let wordPos = 0;
+                while (wordPos < overwriteBefore) {
+                    const ch = word.charCodeAt(wordPos);
+                    if (ch === 32  || ch === 9 ) {
+                        wordPos += 1;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (wordPos >= wordLen) {
+                    item.score = FuzzyScore.Default;
+                }
+                else {
+                    const match = scoreFn(word, wordLow, wordPos, item.completion.label, item.labelLow, 0, this._fuzzyScoreOptions);
+                    if (!match) {
+                        continue;
+                    }
+                    item.score = match;
+                }
+            }
+            item.idx = i;
+            target.push(item);
+            labelLengths.push(item.completion.label.length);
+        }
+        this._filteredItems = target.sort((a, b) => b.score[0] - a.score[0]);
+        this._refilterKind = 0 ;
+        this._stats = {
+            pLabelLen: labelLengths.length ?
+                quickSelect(labelLengths.length - .85, labelLengths, (a, b) => a - b)
+                : 0
+        };
+    }
+}
+export { LineContext, SimpleCompletionModel };