@codingame/monaco-vscode-api 1.83.8 → 1.83.9

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

@@ -1,101 +0,0 @@
-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

@@ -1,26 +0,0 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-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 };

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

@@ -1,23 +0,0 @@
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-class TestCoverage {
-    constructor(accessor) {
-        this.accessor = accessor;
-    }
-    async getAllFiles(token = CancellationToken.None) {
-        if (!this.fileCoverage) {
-            this.fileCoverage = this.accessor.provideFileCoverage(token);
-        }
-        try {
-            return await this.fileCoverage;
-        }
-        catch (e) {
-            this.fileCoverage = undefined;
-            throw e;
-        }
-    }
-    async getUri(uri, token = CancellationToken.None) {
-        const files = await this.getAllFiles(token);
-        return files.find(f => ( f.uri.toString()) === ( uri.toString()));
-    }
-}
-export { TestCoverage };

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

@@ -1,334 +0,0 @@
-import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { language } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { removeAnsiEscapeCodes } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { refreshComputedState } from './getComputedState.js';
-import { MutableObservableValue } from './observableValue.js';
-import { TestId } from './testId.js';
-import { makeEmptyCounts, terminalStatePriorities, maxPriority } from './testingStates.js';
-import { TestResultItem, getMarkId } from './testTypes.js';
-({
-    buffers: [],
-    length: 0,
-    onDidWriteData: Event.None,
-    endPromise: Promise.resolve(),
-    getRange: () => VSBuffer.alloc(0),
-    getRangeIter: () => [],
-});
-class TaskRawOutput {
-    constructor() {
-        this.writeDataEmitter = ( new Emitter());
-        this.endDeferred = ( new DeferredPromise());
-        this.offset = 0;
-        this.onDidWriteData = this.writeDataEmitter.event;
-        this.endPromise = this.endDeferred.p;
-        this.buffers = [];
-    }
-    get length() {
-        return this.offset;
-    }
-    getRange(start, length) {
-        const buf = VSBuffer.alloc(length);
-        let bufLastWrite = 0;
-        for (const chunk of this.getRangeIter(start, length)) {
-            buf.buffer.set(chunk.buffer, bufLastWrite);
-            bufLastWrite += chunk.byteLength;
-        }
-        return bufLastWrite < length ? buf.slice(0, bufLastWrite) : buf;
-    }
-    *getRangeIter(start, length) {
-        let soFar = 0;
-        let internalLastRead = 0;
-        for (const b of this.buffers) {
-            if (internalLastRead + b.byteLength <= start) {
-                internalLastRead += b.byteLength;
-                continue;
-            }
-            const bstart = Math.max(0, start - internalLastRead);
-            const bend = Math.min(b.byteLength, bstart + length - soFar);
-            yield b.slice(bstart, bend);
-            soFar += bend - bstart;
-            internalLastRead += b.byteLength;
-            if (soFar === length) {
-                break;
-            }
-        }
-    }
-    append(data, marker) {
-        const offset = this.offset;
-        let length = data.byteLength;
-        if (marker === undefined) {
-            this.push(data);
-            return { offset, length };
-        }
-        const start = VSBuffer.fromString(getMarkCode(marker, true));
-        const end = VSBuffer.fromString(getMarkCode(marker, false));
-        length += start.byteLength + end.byteLength;
-        this.push(start);
-        let trimLen = data.byteLength;
-        for (; trimLen > 0; trimLen--) {
-            const last = data.buffer[trimLen - 1];
-            if (last !== 13  && last !== 10 ) {
-                break;
-            }
-        }
-        this.push(data.slice(0, trimLen));
-        this.push(end);
-        this.push(data.slice(trimLen));
-        return { offset, length };
-    }
-    push(data) {
-        if (data.byteLength === 0) {
-            return;
-        }
-        this.buffers.push(data);
-        this.writeDataEmitter.fire(data);
-        this.offset += data.byteLength;
-    }
-    end() {
-        this.endDeferred.complete();
-    }
-}
-const getMarkCode = (marker, start) => `\x1b]633;SetMark;Id=${getMarkId(marker, start)};Hidden\x07`;
-const itemToNode = (controllerId, item, parent) => ({
-    controllerId,
-    expand: 0 ,
-    item: { ...item },
-    children: [],
-    tasks: [],
-    ownComputedState: 0 ,
-    computedState: 0 ,
-});
-class LiveTestResult extends Disposable {
-    get completedAt() {
-        return this._completedAt;
-    }
-    get tests() {
-        return ( this.testById.values());
-    }
-    constructor(id, persist, request) {
-        super();
-        this.id = id;
-        this.persist = persist;
-        this.request = request;
-        this.completeEmitter = this._register(( new Emitter()));
-        this.newTaskEmitter = this._register(( new Emitter()));
-        this.endTaskEmitter = this._register(( new Emitter()));
-        this.changeEmitter = this._register(( new Emitter()));
-        this.testById = ( new Map());
-        this.testMarkerCounter = 0;
-        this.startedAt = Date.now();
-        this.onChange = this.changeEmitter.event;
-        this.onComplete = this.completeEmitter.event;
-        this.onNewTask = this.newTaskEmitter.event;
-        this.onEndTask = this.endTaskEmitter.event;
-        this.tasks = [];
-        this.name = ( localizeWithPath(
-            'vs/workbench/contrib/testing/common/testResult',
-            'runFinished',
-            'Test run at {0}',
-            ( new Date()).toLocaleString(language)
-        ));
-        this.counts = makeEmptyCounts();
-        this.computedStateAccessor = {
-            getOwnState: i => i.ownComputedState,
-            getCurrentComputedState: i => i.computedState,
-            setComputedState: (i, s) => i.computedState = s,
-            getChildren: i => i.children,
-            getParents: i => {
-                const { testById: testByExtId } = this;
-                return (function* () {
-                    const parentId = TestId.fromString(i.item.extId).parentId;
-                    if (parentId) {
-                        for (const id of parentId.idsToRoot()) {
-                            yield testByExtId.get(( id.toString()));
-                        }
-                    }
-                })();
-            },
-        };
-        this.doSerialize = ( new Lazy(() => ({
-            id: this.id,
-            completedAt: this.completedAt,
-            tasks: ( this.tasks.map(t => ({ id: t.id, name: t.name }))),
-            name: this.name,
-            request: this.request,
-            items: ( [...( this.testById.values())].map(TestResultItem.serializeWithoutMessages)),
-        })));
-        this.doSerializeWithMessages = ( new Lazy(() => ({
-            id: this.id,
-            completedAt: this.completedAt,
-            tasks: ( this.tasks.map(t => ({ id: t.id, name: t.name }))),
-            name: this.name,
-            request: this.request,
-            items: ( [...( this.testById.values())].map(TestResultItem.serialize)),
-        })));
-    }
-    getStateById(extTestId) {
-        return this.testById.get(extTestId);
-    }
-    appendOutput(output, taskId, location, testId) {
-        const preview = output.byteLength > 100 ? ( output.slice(0, 100).toString()) + '…' : ( output.toString());
-        let marker;
-        if (testId || location) {
-            marker = this.testMarkerCounter++;
-        }
-        const index = this.mustGetTaskIndex(taskId);
-        const task = this.tasks[index];
-        const { offset, length } = task.output.append(output, marker);
-        const message = {
-            location,
-            message: removeAnsiEscapeCodes(preview),
-            offset,
-            length,
-            marker,
-            type: 1 ,
-        };
-        const test = testId && this.testById.get(testId);
-        if (test) {
-            test.tasks[index].messages.push(message);
-            this.changeEmitter.fire({ item: test, result: this, reason: 2 , message });
-        }
-        else {
-            task.otherMessages.push(message);
-        }
-    }
-    addTask(task) {
-        this.tasks.push({ ...task, coverage: this._register(( new MutableObservableValue(undefined))), otherMessages: [], output: ( new TaskRawOutput()) });
-        for (const test of this.tests) {
-            test.tasks.push({ duration: undefined, messages: [], state: 0  });
-        }
-        this.newTaskEmitter.fire(this.tasks.length - 1);
-    }
-    addTestChainToRun(controllerId, chain) {
-        let parent = this.testById.get(chain[0].extId);
-        if (!parent) {
-            parent = this.addTestToRun(controllerId, chain[0], null);
-        }
-        for (let i = 1; i < chain.length; i++) {
-            parent = this.addTestToRun(controllerId, chain[i], parent.item.extId);
-        }
-        return undefined;
-    }
-    updateState(testId, taskId, state, duration) {
-        const entry = this.testById.get(testId);
-        if (!entry) {
-            return;
-        }
-        const index = this.mustGetTaskIndex(taskId);
-        const oldTerminalStatePrio = terminalStatePriorities[entry.tasks[index].state];
-        const newTerminalStatePrio = terminalStatePriorities[state];
-        if (oldTerminalStatePrio !== undefined &&
-            (newTerminalStatePrio === undefined || newTerminalStatePrio < oldTerminalStatePrio)) {
-            return;
-        }
-        this.fireUpdateAndRefresh(entry, index, state, duration);
-    }
-    appendMessage(testId, taskId, message) {
-        const entry = this.testById.get(testId);
-        if (!entry) {
-            return;
-        }
-        entry.tasks[this.mustGetTaskIndex(taskId)].messages.push(message);
-        this.changeEmitter.fire({ item: entry, result: this, reason: 2 , message });
-    }
-    markTaskComplete(taskId) {
-        const index = this.mustGetTaskIndex(taskId);
-        const task = this.tasks[index];
-        task.running = false;
-        task.output.end();
-        this.setAllToState(0 , taskId, t => t.state === 1  || t.state === 2 );
-        this.endTaskEmitter.fire(index);
-    }
-    markComplete() {
-        if (this._completedAt !== undefined) {
-            throw new Error('cannot complete a test result multiple times');
-        }
-        for (const task of this.tasks) {
-            if (task.running) {
-                this.markTaskComplete(task.id);
-            }
-        }
-        this._completedAt = Date.now();
-        this.completeEmitter.fire();
-    }
-    markRetired(testIds) {
-        for (const [id, test] of this.testById) {
-            if (!test.retired && (!testIds || testIds.hasKeyOrParent(TestId.fromString(id).path))) {
-                test.retired = true;
-                this.changeEmitter.fire({ reason: 0 , item: test, result: this });
-            }
-        }
-    }
-    toJSON() {
-        return this.completedAt && this.persist ? this.doSerialize.value : undefined;
-    }
-    toJSONWithMessages() {
-        return this.completedAt && this.persist ? this.doSerializeWithMessages.value : undefined;
-    }
-    setAllToState(state, taskId, when) {
-        const index = this.mustGetTaskIndex(taskId);
-        for (const test of ( this.testById.values())) {
-            if (when(test.tasks[index], test)) {
-                this.fireUpdateAndRefresh(test, index, state);
-            }
-        }
-    }
-    fireUpdateAndRefresh(entry, taskIndex, newState, newOwnDuration) {
-        const previousOwnComputed = entry.ownComputedState;
-        const previousOwnDuration = entry.ownDuration;
-        const changeEvent = {
-            item: entry,
-            result: this,
-            reason: 1 ,
-            previousState: previousOwnComputed,
-            previousOwnDuration: previousOwnDuration,
-        };
-        entry.tasks[taskIndex].state = newState;
-        if (newOwnDuration !== undefined) {
-            entry.tasks[taskIndex].duration = newOwnDuration;
-            entry.ownDuration = Math.max(entry.ownDuration || 0, newOwnDuration);
-        }
-        const newOwnComputed = maxPriority(...( entry.tasks.map(t => t.state)));
-        if (newOwnComputed === previousOwnComputed) {
-            if (newOwnDuration !== previousOwnDuration) {
-                this.changeEmitter.fire(changeEvent);
-            }
-            return;
-        }
-        entry.ownComputedState = newOwnComputed;
-        this.counts[previousOwnComputed]--;
-        this.counts[newOwnComputed]++;
-        refreshComputedState(this.computedStateAccessor, entry).forEach(t => this.changeEmitter.fire(t === entry ? changeEvent : {
-            item: t,
-            result: this,
-            reason: 0 ,
-        }));
-    }
-    addTestToRun(controllerId, item, parent) {
-        const node = itemToNode(controllerId, item);
-        this.testById.set(item.extId, node);
-        this.counts[0 ]++;
-        if (parent) {
-            this.testById.get(parent)?.children.push(node);
-        }
-        if (this.tasks.length) {
-            for (let i = 0; i < this.tasks.length; i++) {
-                node.tasks.push({ duration: undefined, messages: [], state: 0  });
-            }
-        }
-        return node;
-    }
-    mustGetTaskIndex(taskId) {
-        const index = this.tasks.findIndex(t => t.id === taskId);
-        if (index === -1) {
-            throw new Error(`Unknown task ${taskId} in updateState`);
-        }
-        return index;
-    }
-}
-export { LiveTestResult, TaskRawOutput };

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

@@ -1,45 +0,0 @@
-const statePriority = {
-    [2 ]: 6,
-    [6 ]: 5,
-    [4 ]: 4,
-    [1 ]: 3,
-    [3 ]: 2,
-    [0 ]: 0,
-    [5 ]: 1,
-};
-Object.entries(statePriority).reduce((acc, [stateStr, priority]) => {
-    const state = Number(stateStr);
-    acc[state] = { statusNode: true, state, priority };
-    return acc;
-}, {});
-const cmpPriority = (a, b) => statePriority[b] - statePriority[a];
-const maxPriority = (...states) => {
-    switch (states.length) {
-        case 0:
-            return 0 ;
-        case 1:
-            return states[0];
-        case 2:
-            return statePriority[states[0]] > statePriority[states[1]] ? states[0] : states[1];
-        default: {
-            let max = states[0];
-            for (let i = 1; i < states.length; i++) {
-                if (statePriority[max] < statePriority[states[i]]) {
-                    max = states[i];
-                }
-            }
-            return max;
-        }
-    }
-};
-const statesInOrder = ( ( Object.keys(statePriority)).map(s => Number(s))).sort(cmpPriority);
-const terminalStatePriorities = {
-    [3 ]: 0,
-    [5 ]: 1,
-    [4 ]: 2,
-    [6 ]: 3,
-};
-const makeEmptyCounts = () => {
-    return ( new Uint32Array(statesInOrder.length));
-};
-export { cmpPriority, makeEmptyCounts, maxPriority, statePriority, statesInOrder, terminalStatePriorities };