@codingame/monaco-vscode-api 1.83.15-next.0 → 1.83.16

package/vscode/src/vs/workbench/contrib/testing/common/getComputedState.js

@@ -0,0 +1,101 @@
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { statePriority, maxPriority, makeEmptyCounts } from './testingStates.js';
+const isDurationAccessor = (accessor) => 'getOwnDuration' in accessor;
+const getComputedState = (accessor, node, force = false) => {
+    let computed = accessor.getCurrentComputedState(node);
+    if (computed === undefined || force) {
+        computed = accessor.getOwnState(node) ?? 0 ;
+        let childrenCount = 0;
+        const stateMap = makeEmptyCounts();
+        for (const child of accessor.getChildren(node)) {
+            const childComputed = getComputedState(accessor, child);
+            childrenCount++;
+            stateMap[childComputed]++;
+            computed = childComputed === 5  && computed === 0
+                ? 5  : maxPriority(computed, childComputed);
+        }
+        if (childrenCount > LARGE_NODE_THRESHOLD) {
+            largeNodeChildrenStates.set(node, stateMap);
+        }
+        accessor.setComputedState(node, computed);
+    }
+    return computed;
+};
+const getComputedDuration = (accessor, node, force = false) => {
+    let computed = accessor.getCurrentComputedDuration(node);
+    if (computed === undefined || force) {
+        const own = accessor.getOwnDuration(node);
+        if (own !== undefined) {
+            computed = own;
+        }
+        else {
+            computed = undefined;
+            for (const child of accessor.getChildren(node)) {
+                const d = getComputedDuration(accessor, child);
+                if (d !== undefined) {
+                    computed = (computed || 0) + d;
+                }
+            }
+        }
+        accessor.setComputedDuration(node, computed);
+    }
+    return computed;
+};
+const LARGE_NODE_THRESHOLD = 64;
+const largeNodeChildrenStates = ( new WeakMap());
+const refreshComputedState = (accessor, node, explicitNewComputedState, refreshDuration = true) => {
+    const oldState = accessor.getCurrentComputedState(node);
+    const oldPriority = statePriority[oldState];
+    const newState = explicitNewComputedState ?? getComputedState(accessor, node, true);
+    const newPriority = statePriority[newState];
+    const toUpdate = ( new Set());
+    if (newPriority !== oldPriority) {
+        accessor.setComputedState(node, newState);
+        toUpdate.add(node);
+        let moveFromState = oldState;
+        let moveToState = newState;
+        for (const parent of accessor.getParents(node)) {
+            const lnm = largeNodeChildrenStates.get(parent);
+            if (lnm) {
+                lnm[moveFromState]--;
+                lnm[moveToState]++;
+            }
+            const prev = accessor.getCurrentComputedState(parent);
+            if (newPriority > oldPriority) {
+                if (prev !== undefined && statePriority[prev] >= newPriority) {
+                    break;
+                }
+                if (lnm && lnm[moveToState] > 1) {
+                    break;
+                }
+                accessor.setComputedState(parent, newState);
+                toUpdate.add(parent);
+            }
+            else  {
+                if (prev === undefined || statePriority[prev] > oldPriority) {
+                    break;
+                }
+                if (lnm && lnm[moveFromState] > 0) {
+                    break;
+                }
+                moveToState = getComputedState(accessor, parent, true);
+                accessor.setComputedState(parent, moveToState);
+                toUpdate.add(parent);
+            }
+            moveFromState = prev;
+        }
+    }
+    if (isDurationAccessor(accessor) && refreshDuration) {
+        for (const parent of Iterable.concat(Iterable.single(node), accessor.getParents(node))) {
+            const oldDuration = accessor.getCurrentComputedDuration(parent);
+            const newDuration = getComputedDuration(accessor, parent, true);
+            if (oldDuration === newDuration) {
+                break;
+            }
+            accessor.setComputedDuration(parent, newDuration);
+            toUpdate.add(parent);
+        }
+    }
+    return toUpdate;
+};
+export { refreshComputedState };

package/vscode/src/vs/workbench/contrib/testing/common/observableValue.js

@@ -0,0 +1,30 @@
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const staticObservableValue = (value) => ({
+    onDidChange: Event.None,
+    value,
+});
+class MutableObservableValue extends Disposable {
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        if (v !== this._value) {
+            this._value = v;
+            this.changeEmitter.fire(v);
+        }
+    }
+    static stored(stored, defaultValue) {
+        const o = ( new MutableObservableValue(stored.get(defaultValue)));
+        o._register(stored);
+        o._register(o.onDidChange(value => stored.store(value)));
+        return o;
+    }
+    constructor(_value) {
+        super();
+        this._value = _value;
+        this.changeEmitter = this._register(( new Emitter()));
+        this.onDidChange = this.changeEmitter.event;
+    }
+}
+export { MutableObservableValue, staticObservableValue };

package/vscode/src/vs/workbench/contrib/testing/common/storedValue.js

@@ -0,0 +1,36 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+const defaultSerialization = {
+    deserialize: d => JSON.parse(d),
+    serialize: d => JSON.stringify(d),
+};
+let StoredValue = class StoredValue extends Disposable {
+    constructor(options, storage) {
+        super();
+        this.storage = storage;
+        this.key = options.key;
+        this.scope = options.scope;
+        this.target = options.target;
+        this.serialization = options.serialization ?? defaultSerialization;
+        this.onDidChange = this.storage.onDidChangeValue(this.scope, this.key, this._register(( new DisposableStore())));
+    }
+    get(defaultValue) {
+        if (this.value === undefined) {
+            const value = this.storage.get(this.key, this.scope);
+            this.value = value === undefined ? defaultValue : this.serialization.deserialize(value);
+        }
+        return this.value;
+    }
+    store(value) {
+        this.value = value;
+        this.storage.store(this.key, this.serialization.serialize(value), this.scope, this.target);
+    }
+    delete() {
+        this.storage.remove(this.key, this.scope);
+    }
+};
+StoredValue = ( __decorate([
+    ( __param(1, IStorageService))
+], StoredValue));
+export { StoredValue };

package/vscode/src/vs/workbench/contrib/testing/common/testExplorerFilterState.js

@@ -0,0 +1,116 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { splitGlobAware } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { MutableObservableValue } from './observableValue.js';
+import { StoredValue } from './storedValue.js';
+import { namespaceTestTag } from './testTypes.js';
+const ITestExplorerFilterState = ( createDecorator('testingFilterState'));
+const tagRe = /!?@([^ ,:]+)/g;
+const trimExtraWhitespace = (str) => str.replace(/\s\s+/g, ' ').trim();
+let TestExplorerFilterState = class TestExplorerFilterState extends Disposable {
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this.focusEmitter = ( new Emitter());
+        this.termFilterState = {};
+        this.globList = [];
+        this.includeTags = ( new Set());
+        this.excludeTags = ( new Set());
+        this.text = this._register(( new MutableObservableValue('')));
+        this.fuzzy = this._register(MutableObservableValue.stored(( new StoredValue({
+            key: 'testHistoryFuzzy',
+            scope: 0 ,
+            target: 0 ,
+        }, this.storageService)), false));
+        this.reveal = this._register(( new MutableObservableValue(undefined)));
+        this.onDidRequestInputFocus = this.focusEmitter.event;
+    }
+    focusInput() {
+        this.focusEmitter.fire();
+    }
+    setText(text) {
+        if (text === this.text.value) {
+            return;
+        }
+        this.termFilterState = {};
+        this.globList = [];
+        this.includeTags.clear();
+        this.excludeTags.clear();
+        let globText = '';
+        let lastIndex = 0;
+        for (const match of text.matchAll(tagRe)) {
+            let nextIndex = match.index + match[0].length;
+            const tag = match[0];
+            if (allTestFilterTerms.includes(tag)) {
+                this.termFilterState[tag] = true;
+            }
+            if (text[nextIndex] === ':') {
+                nextIndex++;
+                let delimiter = text[nextIndex];
+                if (delimiter !== `"` && delimiter !== `'`) {
+                    delimiter = ' ';
+                }
+                else {
+                    nextIndex++;
+                }
+                let tagId = '';
+                while (nextIndex < text.length && text[nextIndex] !== delimiter) {
+                    if (text[nextIndex] === '\\') {
+                        tagId += text[nextIndex + 1];
+                        nextIndex += 2;
+                    }
+                    else {
+                        tagId += text[nextIndex];
+                        nextIndex++;
+                    }
+                }
+                if (match[0].startsWith('!')) {
+                    this.excludeTags.add(namespaceTestTag(match[1], tagId));
+                }
+                else {
+                    this.includeTags.add(namespaceTestTag(match[1], tagId));
+                }
+                nextIndex++;
+            }
+            globText += text.slice(lastIndex, match.index);
+            lastIndex = nextIndex;
+        }
+        globText += text.slice(lastIndex).trim();
+        if (globText.length) {
+            for (const filter of ( splitGlobAware(globText, ',').map(s => s.trim())).filter(s => !!s.length)) {
+                if (filter.startsWith('!')) {
+                    this.globList.push({ include: false, text: filter.slice(1).toLowerCase() });
+                }
+                else {
+                    this.globList.push({ include: true, text: filter.toLowerCase() });
+                }
+            }
+        }
+        this.text.value = text;
+    }
+    isFilteringFor(term) {
+        return !!this.termFilterState[term];
+    }
+    toggleFilteringFor(term, shouldFilter) {
+        const text = this.text.value.trim();
+        if (shouldFilter !== false && !this.termFilterState[term]) {
+            this.setText(text ? `${text} ${term}` : term);
+        }
+        else if (shouldFilter !== true && this.termFilterState[term]) {
+            this.setText(trimExtraWhitespace(text.replace(term, '')));
+        }
+    }
+};
+TestExplorerFilterState = ( __decorate([
+    ( __param(0, IStorageService))
+], TestExplorerFilterState));
+const allTestFilterTerms = [
+    "@failed" ,
+    "@executed" ,
+    "@doc" ,
+    "@hidden" ,
+];
+export { ITestExplorerFilterState, TestExplorerFilterState };

package/vscode/src/vs/workbench/contrib/testing/common/testProfileService.js

@@ -1,3 +1,174 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { StoredValue } from './storedValue.js';
+import { testRunProfileBitsetList } from './testTypes.js';
+import { TestId } from './testId.js';
+import { TestingContextKeys } from './testingContextKeys.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 const ITestProfileService = ( createDecorator('testProfileService'));
-export { ITestProfileService };
+const canUseProfileWithTest = (profile, test) => profile.controllerId === test.controllerId && (TestId.isRoot(test.item.extId) || !profile.tag || test.item.tags.includes(profile.tag));
+const sorter = (a, b) => {
+    if (a.isDefault !== b.isDefault) {
+        return a.isDefault ? -1 : 1;
+    }
+    return a.label.localeCompare(b.label);
+};
+const capabilityContextKeys = (capabilities) => [
+    [TestingContextKeys.hasRunnableTests.key, ((capabilities & 2) ) !== 0],
+    [TestingContextKeys.hasDebuggableTests.key, ((capabilities & 4) ) !== 0],
+    [TestingContextKeys.hasCoverableTests.key, ((capabilities & 8) ) !== 0],
+];
+let TestProfileService = class TestProfileService extends Disposable {
+    constructor(contextKeyService, storageService) {
+        super();
+        this.changeEmitter = this._register(( new Emitter()));
+        this.controllerProfiles = ( new Map());
+        this.onDidChange = this.changeEmitter.event;
+        this.preferredDefaults = this._register(( new StoredValue({
+            key: 'testingPreferredProfiles',
+            scope: 1 ,
+            target: 1 ,
+        }, storageService)));
+        this.capabilitiesContexts = {
+            [2 ]: TestingContextKeys.hasRunnableTests.bindTo(contextKeyService),
+            [4 ]: TestingContextKeys.hasDebuggableTests.bindTo(contextKeyService),
+            [8 ]: TestingContextKeys.hasCoverableTests.bindTo(contextKeyService),
+            [16 ]: TestingContextKeys.hasNonDefaultProfile.bindTo(contextKeyService),
+            [32 ]: TestingContextKeys.hasConfigurableProfile.bindTo(contextKeyService),
+            [64 ]: TestingContextKeys.supportsContinuousRun.bindTo(contextKeyService),
+        };
+        this.refreshContextKeys();
+    }
+    addProfile(controller, profile) {
+        let record = this.controllerProfiles.get(profile.controllerId);
+        if (record) {
+            record.profiles.push(profile);
+            record.profiles.sort(sorter);
+        }
+        else {
+            record = {
+                profiles: [profile],
+                controller,
+            };
+            this.controllerProfiles.set(profile.controllerId, record);
+        }
+        this.refreshContextKeys();
+        this.changeEmitter.fire();
+    }
+    updateProfile(controllerId, profileId, update) {
+        const ctrl = this.controllerProfiles.get(controllerId);
+        if (!ctrl) {
+            return;
+        }
+        const profile = ctrl.profiles.find(c => c.controllerId === controllerId && c.profileId === profileId);
+        if (!profile) {
+            return;
+        }
+        Object.assign(profile, update);
+        ctrl.profiles.sort(sorter);
+        this.changeEmitter.fire();
+    }
+    configure(controllerId, profileId) {
+        this.controllerProfiles.get(controllerId)?.controller.configureRunProfile(profileId);
+    }
+    removeProfile(controllerId, profileId) {
+        const ctrl = this.controllerProfiles.get(controllerId);
+        if (!ctrl) {
+            return;
+        }
+        if (!profileId) {
+            this.controllerProfiles.delete(controllerId);
+            this.changeEmitter.fire();
+            return;
+        }
+        const index = ctrl.profiles.findIndex(c => c.profileId === profileId);
+        if (index === -1) {
+            return;
+        }
+        ctrl.profiles.splice(index, 1);
+        this.refreshContextKeys();
+        this.changeEmitter.fire();
+    }
+    capabilitiesForTest(test) {
+        const ctrl = this.controllerProfiles.get(test.controllerId);
+        if (!ctrl) {
+            return 0;
+        }
+        let capabilities = 0;
+        for (const profile of ctrl.profiles) {
+            if (!profile.tag || test.item.tags.includes(profile.tag)) {
+                capabilities |= capabilities & profile.group ? 16  : profile.group;
+            }
+        }
+        return capabilities;
+    }
+    all() {
+        return ( this.controllerProfiles.values());
+    }
+    getControllerProfiles(profileId) {
+        return this.controllerProfiles.get(profileId)?.profiles ?? [];
+    }
+    getGroupDefaultProfiles(group) {
+        const preferred = this.preferredDefaults.get();
+        if (!preferred) {
+            return this.getBaseDefaults(group);
+        }
+        const profiles = preferred[group]
+            ?.map(p => this.controllerProfiles.get(p.controllerId)?.profiles.find(c => c.profileId === p.profileId && c.group === group))
+            .filter(isDefined);
+        return profiles?.length ? profiles : this.getBaseDefaults(group);
+    }
+    setGroupDefaultProfiles(group, profiles) {
+        const next = {
+            ...this.preferredDefaults.get(),
+            [group]: ( profiles.map(c => ({ profileId: c.profileId, controllerId: c.controllerId }))),
+        };
+        if (group === 2  || group === 4 ) {
+            const otherGroup = group === 2  ? 4  : 2 ;
+            const previousDefaults = next[otherGroup] || [];
+            let newDefaults = previousDefaults.slice();
+            for (const [ctrlId, { profiles: ctrlProfiles }] of this.controllerProfiles) {
+                const labels = ( new Set(( profiles.filter(p => p.controllerId === ctrlId).map(p => p.label))));
+                const nextByLabels = ctrlProfiles.filter(p => ( labels.has(p.label)) && p.group === otherGroup);
+                if (nextByLabels.length) {
+                    newDefaults = newDefaults.filter(p => p.controllerId !== ctrlId);
+                    newDefaults.push(...( nextByLabels.map(p => ({ profileId: p.profileId, controllerId: p.controllerId }))));
+                }
+            }
+            next[otherGroup] = newDefaults;
+        }
+        this.preferredDefaults.store(next);
+        this.changeEmitter.fire();
+    }
+    getBaseDefaults(group) {
+        const defaults = [];
+        for (const { profiles } of ( this.controllerProfiles.values())) {
+            const profile = profiles.find(c => c.group === group);
+            if (profile) {
+                defaults.push(profile);
+            }
+        }
+        return defaults;
+    }
+    refreshContextKeys() {
+        let allCapabilities = 0;
+        for (const { profiles } of ( this.controllerProfiles.values())) {
+            for (const profile of profiles) {
+                allCapabilities |= allCapabilities & profile.group ? 16  : profile.group;
+                allCapabilities |= profile.supportsContinuousRun ? 64  : 0;
+            }
+        }
+        for (const group of testRunProfileBitsetList) {
+            this.capabilitiesContexts[group].set((allCapabilities & group) !== 0);
+        }
+    }
+};
+TestProfileService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IStorageService))
+], TestProfileService));
+export { ITestProfileService, TestProfileService, canUseProfileWithTest, capabilityContextKeys };