@codingame/monaco-vscode-api 4.4.1 → 4.5.0

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

@@ -1,194 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { deepClone } from '../../../../base/common/objects.js';
-import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { StoredValue } from './storedValue.js';
-import { TestId } from './testId.js';
-import { testRunProfileBitsetList } from './testTypes.js';
-import { TestingContextKeys } from './testingContextKeys.js';
-const ITestProfileService = ( createDecorator('testProfileService'));
-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;
-        storageService.remove('testingPreferredProfiles', 1 );
-        this.userDefaults = this._register(( new StoredValue({
-            key: 'testingPreferredProfiles2',
-            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) {
-        const previousExplicitDefaultValue = this.userDefaults.get()?.[controller.id]?.[profile.profileId];
-        const extended = {
-            ...profile,
-            isDefault: previousExplicitDefaultValue ?? profile.isDefault,
-            wasInitiallyDefault: profile.isDefault,
-        };
-        let record = this.controllerProfiles.get(profile.controllerId);
-        if (record) {
-            record.profiles.push(extended);
-            record.profiles.sort(sorter);
-        }
-        else {
-            record = {
-                profiles: [extended],
-                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);
-        if (update.isDefault !== undefined) {
-            const map = deepClone(this.userDefaults.get({}));
-            setIsDefault(map, profile, update.isDefault);
-            this.userDefaults.store(map);
-        }
-        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) {
-        let defaults = [];
-        for (const { profiles } of ( this.controllerProfiles.values())) {
-            defaults = defaults.concat(profiles.filter(c => c.group === group && c.isDefault));
-        }
-        if (defaults.length === 0) {
-            for (const { profiles } of ( this.controllerProfiles.values())) {
-                const first = profiles.find(p => p.group === group);
-                if (first) {
-                    defaults.push(first);
-                    break;
-                }
-            }
-        }
-        return defaults;
-    }
-    setGroupDefaultProfiles(group, profiles) {
-        const next = {};
-        for (const ctrl of ( this.controllerProfiles.values())) {
-            next[ctrl.controller.id] = {};
-            for (const profile of ctrl.profiles) {
-                if (profile.group !== group) {
-                    continue;
-                }
-                setIsDefault(next, profile, ( profiles.some(p => p.profileId === profile.profileId)));
-            }
-            for (const profile of ctrl.profiles) {
-                if (profile.group === group) {
-                    continue;
-                }
-                const matching = ctrl.profiles.find(p => p.group === group && p.label === profile.label);
-                if (matching) {
-                    setIsDefault(next, profile, matching.isDefault);
-                }
-            }
-            ctrl.profiles.sort(sorter);
-        }
-        this.userDefaults.store(next);
-        this.changeEmitter.fire();
-    }
-    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));
-const setIsDefault = (map, profile, isDefault) => {
-    profile.isDefault = isDefault;
-    map[profile.controllerId] ??= {};
-    if (profile.isDefault !== profile.wasInitiallyDefault) {
-        map[profile.controllerId][profile.profileId] = profile.isDefault;
-    }
-    else {
-        delete map[profile.controllerId][profile.profileId];
-    }
-};
-export { ITestProfileService, TestProfileService, canUseProfileWithTest, capabilityContextKeys };

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

@@ -1,158 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { findFirstIdxMonotonousOrArrLen } from '../../../../base/common/arraysFind.js';
-import { RunOnceScheduler } from '../../../../base/common/async.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { createSingleCallFunction } from '../../../../base/common/functional.js';
-import { Disposable, toDisposable, dispose, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { generateUuid } from '../../../../base/common/uuid.js';
-import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { TestingContextKeys } from './testingContextKeys.js';
-import { ITestProfileService } from './testProfileService.js';
-import { LiveTestResult } from './testResult.js';
-import { RETAIN_MAX_RESULTS, ITestResultStorage } from './testResultStorage.js';
-const isRunningTests = (service) => service.results.length > 0 && service.results[0].completedAt === undefined;
-const ITestResultService = ( createDecorator('testResultService'));
-let TestResultService = class TestResultService extends Disposable {
-    get results() {
-        this.loadResults();
-        return this._results;
-    }
-    constructor(contextKeyService, storage, testProfiles) {
-        super();
-        this.storage = storage;
-        this.testProfiles = testProfiles;
-        this.changeResultEmitter = this._register(( new Emitter()));
-        this._results = [];
-        this._resultsDisposables = [];
-        this.testChangeEmitter = this._register(( new Emitter()));
-        this.onResultsChanged = this.changeResultEmitter.event;
-        this.onTestChanged = this.testChangeEmitter.event;
-        this.loadResults = createSingleCallFunction(() => this.storage.read().then(loaded => {
-            for (let i = loaded.length - 1; i >= 0; i--) {
-                this.push(loaded[i]);
-            }
-        }));
-        this.persistScheduler = ( new RunOnceScheduler(() => this.persistImmediately(), 500));
-        this._register(toDisposable(() => dispose(this._resultsDisposables)));
-        this.isRunning = TestingContextKeys.isRunning.bindTo(contextKeyService);
-        this.hasAnyResults = TestingContextKeys.hasAnyResults.bindTo(contextKeyService);
-    }
-    getStateById(extId) {
-        for (const result of this.results) {
-            const lookup = result.getStateById(extId);
-            if (lookup && lookup.computedState !== 0 ) {
-                return [result, lookup];
-            }
-        }
-        return undefined;
-    }
-    createLiveResult(req) {
-        if ('targets' in req) {
-            const id = generateUuid();
-            return this.push(( new LiveTestResult(id, true, req)));
-        }
-        let profile;
-        if (req.profile) {
-            const profiles = this.testProfiles.getControllerProfiles(req.controllerId);
-            profile = profiles.find(c => c.profileId === req.profile.id);
-        }
-        const resolved = {
-            isUiTriggered: false,
-            targets: [],
-            exclude: req.exclude,
-            continuous: req.continuous,
-        };
-        if (profile) {
-            resolved.targets.push({
-                profileGroup: profile.group,
-                profileId: profile.profileId,
-                controllerId: req.controllerId,
-                testIds: req.include,
-            });
-        }
-        return this.push(( new LiveTestResult(req.id, req.persist, resolved)));
-    }
-    push(result) {
-        if (result.completedAt === undefined) {
-            this.results.unshift(result);
-        }
-        else {
-            const index = findFirstIdxMonotonousOrArrLen(this.results, r => r.completedAt !== undefined && r.completedAt <= result.completedAt);
-            this.results.splice(index, 0, result);
-            this.persistScheduler.schedule();
-        }
-        this.hasAnyResults.set(true);
-        if (this.results.length > RETAIN_MAX_RESULTS) {
-            this.results.pop();
-            this._resultsDisposables.pop()?.dispose();
-        }
-        const ds = ( new DisposableStore());
-        this._resultsDisposables.push(ds);
-        if (result instanceof LiveTestResult) {
-            ds.add(result);
-            ds.add(result.onComplete(() => this.onComplete(result)));
-            ds.add(result.onChange(this.testChangeEmitter.fire, this.testChangeEmitter));
-            this.isRunning.set(true);
-            this.changeResultEmitter.fire({ started: result });
-        }
-        else {
-            this.changeResultEmitter.fire({ inserted: result });
-            for (const item of result.tests) {
-                for (const otherResult of this.results) {
-                    if (otherResult === result) {
-                        this.testChangeEmitter.fire({ item, result, reason: 0  });
-                        break;
-                    }
-                    else if (otherResult.getStateById(item.item.extId) !== undefined) {
-                        break;
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    getResult(id) {
-        return this.results.find(r => r.id === id);
-    }
-    clear() {
-        const keep = [];
-        const removed = [];
-        for (const result of this.results) {
-            if (result.completedAt !== undefined) {
-                removed.push(result);
-            }
-            else {
-                keep.push(result);
-            }
-        }
-        this._results = keep;
-        this.persistScheduler.schedule();
-        if (keep.length === 0) {
-            this.hasAnyResults.set(false);
-        }
-        this.changeResultEmitter.fire({ removed });
-    }
-    onComplete(result) {
-        this.resort();
-        this.updateIsRunning();
-        this.persistScheduler.schedule();
-        this.changeResultEmitter.fire({ completed: result });
-    }
-    resort() {
-        this.results.sort((a, b) => (b.completedAt ?? Number.MAX_SAFE_INTEGER) - (a.completedAt ?? Number.MAX_SAFE_INTEGER));
-    }
-    updateIsRunning() {
-        this.isRunning.set(isRunningTests(this));
-    }
-    async persistImmediately() {
-        await this.loadResults();
-        this.storage.persist(this.results);
-    }
-};
-TestResultService = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, ITestResultStorage)),
-    ( __param(2, ITestProfileService))
-], TestResultService));
-export { ITestResultService, TestResultService };

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

@@ -1,160 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { VSBuffer, bufferToStream, newWriteableBufferStream } from '../../../../base/common/buffer.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { isDefined } from '../../../../base/common/types.js';
-import { URI } from '../../../../base/common/uri.js';
-import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { StoredValue } from './storedValue.js';
-import { HydratedTestResult } from './testResult.js';
-const RETAIN_MAX_RESULTS = 128;
-const RETAIN_MIN_RESULTS = 16;
-const RETAIN_MAX_BYTES = 1024 * 128;
-const CLEANUP_PROBABILITY = 0.2;
-const ITestResultStorage = ( createDecorator('ITestResultStorage'));
-const currentRevision = 1;
-let BaseTestResultStorage = class BaseTestResultStorage extends Disposable {
-    constructor(uriIdentityService, storageService, logService) {
-        super();
-        this.uriIdentityService = uriIdentityService;
-        this.storageService = storageService;
-        this.logService = logService;
-        this.stored = this._register(( new StoredValue({
-            key: 'storedTestResults',
-            scope: 1 ,
-            target: 1
-        }, this.storageService)));
-    }
-    async read() {
-        const results = await Promise.all(( this.stored.get([]).map(async ({ id, rev }) => {
-            if (rev !== currentRevision) {
-                return undefined;
-            }
-            try {
-                const contents = await this.readForResultId(id);
-                if (!contents) {
-                    return undefined;
-                }
-                return ( new HydratedTestResult(this.uriIdentityService, contents));
-            }
-            catch (e) {
-                this.logService.warn(`Error deserializing stored test result ${id}`, e);
-                return undefined;
-            }
-        })));
-        return results.filter(isDefined);
-    }
-    getResultOutputWriter(resultId) {
-        const stream = newWriteableBufferStream();
-        this.storeOutputForResultId(resultId, stream);
-        return stream;
-    }
-    async persist(results) {
-        const toDelete = ( new Map(( this.stored.get([]).map(({ id, bytes }) => [id, bytes]))));
-        const toStore = [];
-        const todo = [];
-        let budget = RETAIN_MAX_BYTES;
-        for (let i = 0; i < results.length && i < RETAIN_MAX_RESULTS && (budget > 0 || toStore.length < RETAIN_MIN_RESULTS); i++) {
-            const result = results[i];
-            const existingBytes = toDelete.get(result.id);
-            if (existingBytes !== undefined) {
-                toDelete.delete(result.id);
-                toStore.push({ id: result.id, rev: currentRevision, bytes: existingBytes });
-                budget -= existingBytes;
-                continue;
-            }
-            const obj = result.toJSON();
-            if (!obj) {
-                continue;
-            }
-            const contents = VSBuffer.fromString(JSON.stringify(obj));
-            todo.push(this.storeForResultId(result.id, obj));
-            toStore.push({ id: result.id, rev: currentRevision, bytes: contents.byteLength });
-            budget -= contents.byteLength;
-        }
-        for (const id of ( toDelete.keys())) {
-            todo.push(this.deleteForResultId(id).catch(() => undefined));
-        }
-        this.stored.store(toStore);
-        await Promise.all(todo);
-    }
-};
-BaseTestResultStorage = ( __decorate([
-    ( __param(0, IUriIdentityService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, ILogService))
-], BaseTestResultStorage));
-let TestResultStorage = class TestResultStorage extends BaseTestResultStorage {
-    constructor(uriIdentityService, storageService, logService, workspaceContext, fileService, environmentService) {
-        super(uriIdentityService, storageService, logService);
-        this.fileService = fileService;
-        this.directory = URI.joinPath(environmentService.workspaceStorageHome, workspaceContext.getWorkspace().id, 'testResults');
-    }
-    async readForResultId(id) {
-        const contents = await this.fileService.readFile(this.getResultJsonPath(id));
-        return JSON.parse(( contents.value.toString()));
-    }
-    storeForResultId(id, contents) {
-        return this.fileService.writeFile(this.getResultJsonPath(id), VSBuffer.fromString(JSON.stringify(contents)));
-    }
-    deleteForResultId(id) {
-        return this.fileService.del(this.getResultJsonPath(id)).catch(() => undefined);
-    }
-    async readOutputRangeForResultId(id, offset, length) {
-        try {
-            const { value } = await this.fileService.readFile(this.getResultOutputPath(id), { position: offset, length });
-            return value;
-        }
-        catch {
-            return VSBuffer.alloc(0);
-        }
-    }
-    async readOutputForResultId(id) {
-        try {
-            const { value } = await this.fileService.readFileStream(this.getResultOutputPath(id));
-            return value;
-        }
-        catch {
-            return bufferToStream(VSBuffer.alloc(0));
-        }
-    }
-    async storeOutputForResultId(id, input) {
-        await this.fileService.createFile(this.getResultOutputPath(id), input);
-    }
-    async persist(results) {
-        await super.persist(results);
-        if (Math.random() < CLEANUP_PROBABILITY) {
-            await this.cleanupDereferenced();
-        }
-    }
-    async cleanupDereferenced() {
-        const { children } = await this.fileService.resolve(this.directory);
-        if (!children) {
-            return;
-        }
-        const stored = ( new Set(( this.stored.get([]).filter(s => s.rev === currentRevision).map(s => s.id))));
-        await Promise.all(( children
-            .filter(child => !( stored.has(child.name.replace(/\.[a-z]+$/, ''))))
-            .map(child => this.fileService.del(child.resource).catch(() => undefined))));
-    }
-    getResultJsonPath(id) {
-        return URI.joinPath(this.directory, `${id}.json`);
-    }
-    getResultOutputPath(id) {
-        return URI.joinPath(this.directory, `${id}.output`);
-    }
-};
-TestResultStorage = ( __decorate([
-    ( __param(0, IUriIdentityService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IWorkspaceContextService)),
-    ( __param(4, IFileService)),
-    ( __param(5, IEnvironmentService))
-], TestResultStorage));
-export { BaseTestResultStorage, ITestResultStorage, RETAIN_MAX_RESULTS, TestResultStorage };

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

@@ -1,102 +0,0 @@
-import { CancellationToken } from '../../../../base/common/cancellation.js';
-import { Iterable } from '../../../../base/common/iterator.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { TestId } from './testId.js';
-const ITestService = ( createDecorator('testService'));
-const testCollectionIsEmpty = (collection) => !( Iterable.some(collection.rootItems, r => r.children.size > 0));
-const getContextForTestItem = (collection, id) => {
-    if (typeof id === 'string') {
-        id = TestId.fromString(id);
-    }
-    if (id.isRoot) {
-        return { controller: ( id.toString()) };
-    }
-    const context = { $mid: 16 , tests: [] };
-    for (const i of id.idsFromRoot()) {
-        if (!i.isRoot) {
-            const test = collection.getNodeById(( i.toString()));
-            if (test) {
-                context.tests.push(test);
-            }
-        }
-    }
-    return context;
-};
-const expandAndGetTestById = async (collection, id, ct = CancellationToken.None) => {
-    const idPath = [...TestId.fromString(id).idsFromRoot()];
-    let expandToLevel = 0;
-    for (let i = idPath.length - 1; !ct.isCancellationRequested && i >= expandToLevel;) {
-        const id = ( idPath[i].toString());
-        const existing = collection.getNodeById(id);
-        if (!existing) {
-            i--;
-            continue;
-        }
-        if (i === idPath.length - 1) {
-            return existing;
-        }
-        if (!( existing.children.has(( idPath[i + 1].toString())))) {
-            await collection.expand(id, 0);
-        }
-        expandToLevel = i + 1;
-        i = idPath.length - 1;
-    }
-    return undefined;
-};
-const waitForTestToBeIdle = (testService, test) => {
-    if (!test.item.busy) {
-        return;
-    }
-    return ( new Promise(resolve => {
-        const l = testService.onDidProcessDiff(() => {
-            if (testService.collection.getNodeById(test.item.extId)?.item.busy !== true) {
-                resolve();
-                l.dispose();
-            }
-        });
-    }));
-};
-const testsInFile = async function* (testService, ident, uri, waitForIdle = true) {
-    for (const test of testService.collection.all) {
-        if (!test.item.uri) {
-            continue;
-        }
-        if (ident.extUri.isEqual(uri, test.item.uri)) {
-            yield test;
-        }
-        if (ident.extUri.isEqualOrParent(uri, test.item.uri)) {
-            if (test.expand === 1 ) {
-                await testService.collection.expand(test.item.extId, 1);
-            }
-            if (waitForIdle) {
-                await waitForTestToBeIdle(testService, test);
-            }
-        }
-    }
-};
-const testsUnderUri = async function* (testService, ident, uri, waitForIdle = true) {
-    const queue = [testService.collection.rootIds];
-    while (queue.length) {
-        for (const testId of queue.pop()) {
-            const test = testService.collection.getNodeById(testId);
-            if (!test) ;
-            else if (!test.item.uri) {
-                queue.push(( test.children.values()));
-                continue;
-            }
-            else if (ident.extUri.isEqualOrParent(uri, test.item.uri)) {
-                if (test.expand === 1 ) {
-                    await testService.collection.expand(test.item.extId, 1);
-                }
-                if (waitForIdle) {
-                    await waitForTestToBeIdle(testService, test);
-                }
-                queue.push(( test.children.values()));
-            }
-            else if (ident.extUri.isEqualOrParent(test.item.uri, uri)) {
-                yield test;
-            }
-        }
-    }
-};
-export { ITestService, expandAndGetTestById, getContextForTestItem, testCollectionIsEmpty, testsInFile, testsUnderUri };