@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/contrib/tasks/common/taskDefinitionRegistry.js

@@ -0,0 +1,161 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+const taskDefinitionSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        type: {
+            type: 'string',
+            description: ( nls.localize(
+                'TaskDefinition.description',
+                'The actual task type. Please note that types starting with a \'$\' are reserved for internal usage.'
+            ))
+        },
+        required: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        properties: {
+            type: 'object',
+            description: ( nls.localize('TaskDefinition.properties', 'Additional properties of the task type')),
+            additionalProperties: {
+                $ref: 'http://json-schema.org/draft-07/schema#'
+            }
+        },
+        when: {
+            type: 'string',
+            markdownDescription: ( nls.localize(
+                'TaskDefinition.when',
+                'Condition which must be true to enable this type of task. Consider using `shellExecutionSupported`, `processExecutionSupported`, and `customExecutionSupported` as appropriate for this task definition. See the [API documentation](https://code.visualstudio.com/api/extension-guides/task-provider#when-clause) for more information.'
+            )),
+            default: ''
+        }
+    }
+};
+var Configuration;
+( (function(Configuration) {
+    function from(value, extensionId, messageCollector) {
+        if (!value) {
+            return undefined;
+        }
+        const taskType = types.isString(value.type) ? value.type : undefined;
+        if (!taskType || taskType.length === 0) {
+            messageCollector.error(( nls.localize(
+                'TaskTypeConfiguration.noType',
+                'The task type configuration is missing the required \'taskType\' property'
+            )));
+            return undefined;
+        }
+        const required = [];
+        if (Array.isArray(value.required)) {
+            for (const element of value.required) {
+                if (types.isString(element)) {
+                    required.push(element);
+                }
+            }
+        }
+        return {
+            extensionId: extensionId.value,
+            taskType, required: required,
+            properties: value.properties ? objects.deepClone(value.properties) : {},
+            when: value.when ? ContextKeyExpr.deserialize(value.when) : undefined
+        };
+    }
+    Configuration.from = from;
+})(Configuration || (Configuration = {})));
+const taskDefinitionsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'taskDefinitions',
+    activationEventsGenerator: (contributions, result) => {
+        for (const task of contributions) {
+            if (task.type) {
+                result.push(`onTaskType:${task.type}`);
+            }
+        }
+    },
+    jsonSchema: {
+        description: ( nls.localize('TaskDefinitionExtPoint', 'Contributes task kinds')),
+        type: 'array',
+        items: taskDefinitionSchema
+    }
+}));
+class TaskDefinitionRegistryImpl {
+    constructor() {
+        this._onDefinitionsChanged = ( new Emitter());
+        this.onDefinitionsChanged = this._onDefinitionsChanged.event;
+        this.taskTypes = Object.create(null);
+        this.readyPromise = ( new Promise((resolve, reject) => {
+            taskDefinitionsExtPoint.setHandler((extensions, delta) => {
+                this._schema = undefined;
+                try {
+                    for (const extension of delta.removed) {
+                        const taskTypes = extension.value;
+                        for (const taskType of taskTypes) {
+                            if (this.taskTypes && taskType.type && this.taskTypes[taskType.type]) {
+                                delete this.taskTypes[taskType.type];
+                            }
+                        }
+                    }
+                    for (const extension of delta.added) {
+                        const taskTypes = extension.value;
+                        for (const taskType of taskTypes) {
+                            const type = Configuration.from(taskType, extension.description.identifier, extension.collector);
+                            if (type) {
+                                this.taskTypes[type.taskType] = type;
+                            }
+                        }
+                    }
+                    if ((delta.removed.length > 0) || (delta.added.length > 0)) {
+                        this._onDefinitionsChanged.fire();
+                    }
+                }
+                catch (error) {
+                }
+                resolve(undefined);
+            });
+        }));
+    }
+    onReady() {
+        return this.readyPromise;
+    }
+    get(key) {
+        return this.taskTypes[key];
+    }
+    all() {
+        return ( ( Object.keys(this.taskTypes)).map(key => this.taskTypes[key]));
+    }
+    getJsonSchema() {
+        if (this._schema === undefined) {
+            const schemas = [];
+            for (const definition of this.all()) {
+                const schema = {
+                    type: 'object',
+                    additionalProperties: false
+                };
+                if (definition.required.length > 0) {
+                    schema.required = definition.required.slice(0);
+                }
+                if (definition.properties !== undefined) {
+                    schema.properties = objects.deepClone(definition.properties);
+                }
+                else {
+                    schema.properties = Object.create(null);
+                }
+                schema.properties.type = {
+                    type: 'string',
+                    enum: [definition.taskType]
+                };
+                schemas.push(schema);
+            }
+            this._schema = { oneOf: schemas };
+        }
+        return this._schema;
+    }
+}
+const TaskDefinitionRegistry = ( new TaskDefinitionRegistryImpl());
+export { TaskDefinitionRegistry };

package/dist/vscode/vs/workbench/contrib/tasks/common/taskService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ITaskService = ( createDecorator('taskService'));
+export { ITaskService };

package/dist/vscode/vs/workbench/contrib/testing/common/testId.js

@@ -0,0 +1,109 @@
+class TestId {
+    static fromExtHostTestItem(item, rootId, parent = item.parent) {
+        if (item._isRoot) {
+            return ( new TestId([rootId]));
+        }
+        const path = [item.id];
+        for (let i = parent; i && i.id !== rootId; i = i.parent) {
+            path.push(i.id);
+        }
+        path.push(rootId);
+        return ( new TestId(path.reverse()));
+    }
+    static isRoot(idString) {
+        return !idString.includes("\0" );
+    }
+    static root(idString) {
+        const idx = idString.indexOf("\0" );
+        return idx === -1 ? idString : idString.slice(0, idx);
+    }
+    static fromString(idString) {
+        return ( new TestId(idString.split("\0" )));
+    }
+    static join(base, b) {
+        return ( new TestId([...base.path, b]));
+    }
+    static joinToString(base, b) {
+        return ( base.toString()) + "\0"  + b;
+    }
+    static parentId(idString) {
+        const idx = idString.lastIndexOf("\0" );
+        return idx === -1 ? undefined : idString.slice(0, idx);
+    }
+    static localId(idString) {
+        const idx = idString.lastIndexOf("\0" );
+        return idx === -1 ? idString : idString.slice(idx + "\0" .length);
+    }
+    static compare(a, b) {
+        if (a === b) {
+            return 0 ;
+        }
+        if (b.startsWith(a + "\0" )) {
+            return 2 ;
+        }
+        if (a.startsWith(b + "\0" )) {
+            return 3 ;
+        }
+        return 1 ;
+    }
+    constructor(path, viewEnd = path.length) {
+        this.path = path;
+        this.viewEnd = viewEnd;
+        if (path.length === 0 || viewEnd < 1) {
+            throw new Error('cannot create test with empty path');
+        }
+    }
+    get parentId() {
+        return this.viewEnd > 1 ? ( new TestId(this.path, this.viewEnd - 1)) : undefined;
+    }
+    get localId() {
+        return this.path[this.viewEnd - 1];
+    }
+    get controllerId() {
+        return this.path[0];
+    }
+    get isRoot() {
+        return this.viewEnd === 1;
+    }
+    *idsFromRoot() {
+        for (let i = 1; i <= this.viewEnd; i++) {
+            yield ( new TestId(this.path, i));
+        }
+    }
+    *idsToRoot() {
+        for (let i = this.viewEnd; i > 0; i--) {
+            yield ( new TestId(this.path, i));
+        }
+    }
+    compare(other) {
+        if (typeof other === 'string') {
+            return TestId.compare(( this.toString()), other);
+        }
+        for (let i = 0; i < other.viewEnd && i < this.viewEnd; i++) {
+            if (other.path[i] !== this.path[i]) {
+                return 1 ;
+            }
+        }
+        if (other.viewEnd > this.viewEnd) {
+            return 2 ;
+        }
+        if (other.viewEnd < this.viewEnd) {
+            return 3 ;
+        }
+        return 0 ;
+    }
+    toJSON() {
+        return ( this.toString());
+    }
+    toString() {
+        if (!this.stringifed) {
+            this.stringifed = this.path[0];
+            for (let i = 1; i < this.viewEnd; i++) {
+                this.stringifed += "\0" ;
+                this.stringifed += this.path[i];
+            }
+        }
+        return this.stringifed;
+    }
+}
+export { TestId };

package/dist/vscode/vs/workbench/contrib/testing/common/testItemCollection.js

@@ -0,0 +1,75 @@
+class DuplicateTestItemError extends Error {
+    constructor(id) {
+        super(`Attempted to insert a duplicate test item ID ${id}`);
+    }
+}
+class InvalidTestItemError extends Error {
+    constructor(id) {
+        super(`TestItem with ID "${id}" is invalid. Make sure to create it from the createTestItem method.`);
+    }
+}
+class MixedTestItemController extends Error {
+    constructor(id, ctrlA, ctrlB) {
+        super(`TestItem with ID "${id}" is from controller "${ctrlA}" and cannot be added as a child of an item from controller "${ctrlB}".`);
+    }
+}
+const createTestItemChildren = (api, getApi, checkCtor) => {
+    let mapped = ( new Map());
+    return {
+        get size() {
+            return mapped.size;
+        },
+        forEach(callback, thisArg) {
+            for (const item of ( mapped.values())) {
+                callback.call(thisArg, item, this);
+            }
+        },
+        [Symbol.iterator]() {
+            return mapped.entries();
+        },
+        replace(items) {
+            const newMapped = ( new Map());
+            const toDelete = ( new Set(( mapped.keys())));
+            const bulk = { op: 5 , ops: [] };
+            for (const item of items) {
+                if (!(item instanceof checkCtor)) {
+                    throw new InvalidTestItemError(item.id);
+                }
+                const itemController = getApi(item).controllerId;
+                if (itemController !== api.controllerId) {
+                    throw new MixedTestItemController(item.id, itemController, api.controllerId);
+                }
+                if (newMapped.has(item.id)) {
+                    throw new DuplicateTestItemError(item.id);
+                }
+                newMapped.set(item.id, item);
+                toDelete.delete(item.id);
+                bulk.ops.push({ op: 0 , item });
+            }
+            for (const id of ( toDelete.keys())) {
+                bulk.ops.push({ op: 3 , id });
+            }
+            api.listener?.(bulk);
+            mapped = newMapped;
+        },
+        add(item) {
+            if (!(item instanceof checkCtor)) {
+                throw new InvalidTestItemError(item.id);
+            }
+            mapped.set(item.id, item);
+            api.listener?.({ op: 0 , item });
+        },
+        delete(id) {
+            if (mapped.delete(id)) {
+                api.listener?.({ op: 3 , id });
+            }
+        },
+        get(itemId) {
+            return mapped.get(itemId);
+        },
+        toJSON() {
+            return Array.from(( mapped.values()));
+        },
+    };
+};
+export { DuplicateTestItemError, InvalidTestItemError, MixedTestItemController, createTestItemChildren };

package/dist/vscode/vs/workbench/contrib/testing/common/testTypes.js

@@ -0,0 +1,7 @@
+const testTagDelimiter = '\0';
+const namespaceTestTag = (ctrlId, tagId) => ctrlId + testTagDelimiter + tagId;
+const denamespaceTestTag = (namespaced) => {
+    const index = namespaced.indexOf(testTagDelimiter);
+    return { ctrlId: namespaced.slice(0, index), tagId: namespaced.slice(index + 1) };
+};
+export { denamespaceTestTag, namespaceTestTag };

package/dist/vscode/vs/workbench/contrib/typeHierarchy/common/typeHierarchy.js

@@ -0,0 +1,133 @@
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { RefCountedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+const TypeHierarchyProviderRegistry = ( new LanguageFeatureRegistry());
+class TypeHierarchyModel {
+    static async create(model, position, token) {
+        const [provider] = TypeHierarchyProviderRegistry.ordered(model);
+        if (!provider) {
+            return undefined;
+        }
+        const session = await provider.prepareTypeHierarchy(model, position, token);
+        if (!session) {
+            return undefined;
+        }
+        return ( new TypeHierarchyModel(
+            session.roots.reduce((p, c) => p + c._sessionId, ''),
+            provider,
+            session.roots,
+            ( new RefCountedDisposable(session))
+        ));
+    }
+    constructor(id, provider, roots, ref) {
+        this.id = id;
+        this.provider = provider;
+        this.roots = roots;
+        this.ref = ref;
+        this.root = roots[0];
+    }
+    dispose() {
+        this.ref.release();
+    }
+    fork(item) {
+        const that = this;
+        return new (class extends TypeHierarchyModel {
+            constructor() {
+                super(that.id, that.provider, [item], that.ref.acquire());
+            }
+        });
+    }
+    async provideSupertypes(item, token) {
+        try {
+            const result = await this.provider.provideSupertypes(item, token);
+            if (isNonEmptyArray(result)) {
+                return result;
+            }
+        }
+        catch (e) {
+            onUnexpectedExternalError(e);
+        }
+        return [];
+    }
+    async provideSubtypes(item, token) {
+        try {
+            const result = await this.provider.provideSubtypes(item, token);
+            if (isNonEmptyArray(result)) {
+                return result;
+            }
+        }
+        catch (e) {
+            onUnexpectedExternalError(e);
+        }
+        return [];
+    }
+}
+const _models = ( new Map());
+CommandsRegistry.registerCommand('_executePrepareTypeHierarchy', async (accessor, ...args) => {
+    const [resource, position] = args;
+    assertType(URI.isUri(resource));
+    assertType(Position.isIPosition(position));
+    const modelService = accessor.get(IModelService);
+    let textModel = modelService.getModel(resource);
+    let textModelReference;
+    if (!textModel) {
+        const textModelService = accessor.get(ITextModelService);
+        const result = await textModelService.createModelReference(resource);
+        textModel = result.object.textEditorModel;
+        textModelReference = result;
+    }
+    try {
+        const model = await TypeHierarchyModel.create(textModel, position, CancellationToken.None);
+        if (!model) {
+            return [];
+        }
+        _models.set(model.id, model);
+        _models.forEach((value, key, map) => {
+            if (map.size > 10) {
+                value.dispose();
+                _models.delete(key);
+            }
+        });
+        return [model.root];
+    }
+    finally {
+        textModelReference?.dispose();
+    }
+});
+function isTypeHierarchyItemDto(obj) {
+    const item = obj;
+    return typeof obj === 'object'
+        && typeof item.name === 'string'
+        && typeof item.kind === 'number'
+        && URI.isUri(item.uri)
+        && Range.isIRange(item.range)
+        && Range.isIRange(item.selectionRange);
+}
+CommandsRegistry.registerCommand('_executeProvideSupertypes', async (_accessor, ...args) => {
+    const [item] = args;
+    assertType(isTypeHierarchyItemDto(item));
+    const model = _models.get(item._sessionId);
+    if (!model) {
+        return undefined;
+    }
+    return model.provideSupertypes(item, CancellationToken.None);
+});
+CommandsRegistry.registerCommand('_executeProvideSubtypes', async (_accessor, ...args) => {
+    const [item] = args;
+    assertType(isTypeHierarchyItemDto(item));
+    const model = _models.get(item._sessionId);
+    if (!model) {
+        return undefined;
+    }
+    return model.provideSubtypes(item, CancellationToken.None);
+});
+export { TypeHierarchyModel, TypeHierarchyProviderRegistry };