@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

package/vscode/src/vs/platform/instantiation/common/graph.js

@@ -0,0 +1,84 @@
+class Node {
+    constructor(key, data) {
+        this.key = key;
+        this.data = data;
+        this.incoming = ( new Map());
+        this.outgoing = ( new Map());
+    }
+}
+class Graph {
+    constructor(_hashFn) {
+        this._hashFn = _hashFn;
+        this._nodes = ( new Map());
+    }
+    roots() {
+        const ret = [];
+        for (const node of ( this._nodes.values())) {
+            if (node.outgoing.size === 0) {
+                ret.push(node);
+            }
+        }
+        return ret;
+    }
+    insertEdge(from, to) {
+        const fromNode = this.lookupOrInsertNode(from);
+        const toNode = this.lookupOrInsertNode(to);
+        fromNode.outgoing.set(toNode.key, toNode);
+        toNode.incoming.set(fromNode.key, fromNode);
+    }
+    removeNode(data) {
+        const key = this._hashFn(data);
+        this._nodes.delete(key);
+        for (const node of ( this._nodes.values())) {
+            node.outgoing.delete(key);
+            node.incoming.delete(key);
+        }
+    }
+    lookupOrInsertNode(data) {
+        const key = this._hashFn(data);
+        let node = this._nodes.get(key);
+        if (!node) {
+            node = ( new Node(key, data));
+            this._nodes.set(key, node);
+        }
+        return node;
+    }
+    lookup(data) {
+        return this._nodes.get(this._hashFn(data));
+    }
+    isEmpty() {
+        return this._nodes.size === 0;
+    }
+    toString() {
+        const data = [];
+        for (const [key, value] of this._nodes) {
+            data.push(`${key}\n\t(-> incoming)[${[...( value.incoming.keys())].join(', ')}]\n\t(outgoing ->)[${[...( value.outgoing.keys())].join(',')}]\n`);
+        }
+        return data.join('\n');
+    }
+    findCycleSlow() {
+        for (const [id, node] of this._nodes) {
+            const seen = ( new Set([id]));
+            const res = this._findCycle(node, seen);
+            if (res) {
+                return res;
+            }
+        }
+        return undefined;
+    }
+    _findCycle(node, seen) {
+        for (const [id, outgoing] of node.outgoing) {
+            if (( seen.has(id))) {
+                return [...seen, id].join(' -> ');
+            }
+            seen.add(id);
+            const value = this._findCycle(outgoing, seen);
+            if (value) {
+                return value;
+            }
+            seen.delete(id);
+        }
+        return undefined;
+    }
+}
+export { Graph, Node };

package/vscode/src/vs/platform/instantiation/common/instantiation.js

@@ -0,0 +1,38 @@
+var _util;
+( (function(_util) {
+    _util.serviceIds = ( new Map());
+    _util.DI_TARGET = '$di$target';
+    _util.DI_DEPENDENCIES = '$di$dependencies';
+    function getServiceDependencies(ctor) {
+        return ctor[_util.DI_DEPENDENCIES] || [];
+    }
+    _util.getServiceDependencies = getServiceDependencies;
+})(_util || (_util = {})));
+const IInstantiationService = ( createDecorator('instantiationService'));
+function storeServiceDependency(id, target, index) {
+    if (target[_util.DI_TARGET] === target) {
+        target[_util.DI_DEPENDENCIES].push({ id, index });
+    }
+    else {
+        target[_util.DI_DEPENDENCIES] = [{ id, index }];
+        target[_util.DI_TARGET] = target;
+    }
+}
+function createDecorator(serviceId) {
+    if (( _util.serviceIds.has(serviceId))) {
+        return _util.serviceIds.get(serviceId);
+    }
+    const id = function (target, key, index) {
+        if (arguments.length !== 3) {
+            throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
+        }
+        storeServiceDependency(id, target, index);
+    };
+    id.toString = () => serviceId;
+    _util.serviceIds.set(serviceId, id);
+    return id;
+}
+function refineServiceDecorator(serviceIdentifier) {
+    return serviceIdentifier;
+}
+export { IInstantiationService, _util, createDecorator, refineServiceDecorator };

package/vscode/src/vs/platform/instantiation/common/instantiationService.js

@@ -0,0 +1,314 @@
+import { GlobalIdleValue } from '../../../base/common/async.js';
+import { illegalState } from '../../../base/common/errors.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+import { SyncDescriptor } from './descriptors.js';
+import { Graph } from './graph.js';
+import { IInstantiationService, _util } from './instantiation.js';
+import { ServiceCollection } from './serviceCollection.js';
+import { LinkedList } from '../../../base/common/linkedList.js';
+const _enableAllTracing = false;
+class CyclicDependencyError extends Error {
+    constructor(graph) {
+        super('cyclic dependency between services');
+        this.message = graph.findCycleSlow() ?? `UNABLE to detect cycle, dumping graph: \n${( graph.toString())}`;
+    }
+}
+class InstantiationService {
+    constructor(_services = ( new ServiceCollection()), _strict = false, _parent, _enableTracing = _enableAllTracing) {
+        this._services = _services;
+        this._strict = _strict;
+        this._parent = _parent;
+        this._enableTracing = _enableTracing;
+        this._activeInstantiations = ( new Set());
+        this._services.set(IInstantiationService, this);
+        this._globalGraph = _enableTracing ? _parent?._globalGraph ?? ( new Graph(e => e)) : undefined;
+    }
+    createChild(services) {
+        return ( new InstantiationService(services, this._strict, this, this._enableTracing));
+    }
+    invokeFunction(fn, ...args) {
+        const _trace = Trace.traceInvocation(this._enableTracing, fn);
+        let _done = false;
+        try {
+            const accessor = {
+                get: (id) => {
+                    if (_done) {
+                        throw illegalState('service accessor is only valid during the invocation of its target method');
+                    }
+                    const result = this._getOrCreateServiceInstance(id, _trace);
+                    if (!result) {
+                        throw new Error(`[invokeFunction] unknown service '${id}'`);
+                    }
+                    return result;
+                }
+            };
+            return fn(accessor, ...args);
+        }
+        finally {
+            _done = true;
+            _trace.stop();
+        }
+    }
+    createInstance(ctorOrDescriptor, ...rest) {
+        let _trace;
+        let result;
+        if (ctorOrDescriptor instanceof SyncDescriptor) {
+            _trace = Trace.traceCreation(this._enableTracing, ctorOrDescriptor.ctor);
+            result = this._createInstance(ctorOrDescriptor.ctor, ctorOrDescriptor.staticArguments.concat(rest), _trace);
+        }
+        else {
+            _trace = Trace.traceCreation(this._enableTracing, ctorOrDescriptor);
+            result = this._createInstance(ctorOrDescriptor, rest, _trace);
+        }
+        _trace.stop();
+        return result;
+    }
+    _createInstance(ctor, args = [], _trace) {
+        const serviceDependencies = _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index);
+        const serviceArgs = [];
+        for (const dependency of serviceDependencies) {
+            const service = this._getOrCreateServiceInstance(dependency.id, _trace);
+            if (!service) {
+                this._throwIfStrict(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`, false);
+            }
+            serviceArgs.push(service);
+        }
+        const firstServiceArgPos = serviceDependencies.length > 0 ? serviceDependencies[0].index : args.length;
+        if (args.length !== firstServiceArgPos) {
+            console.trace(`[createInstance] First service dependency of ${ctor.name} at position ${firstServiceArgPos + 1} conflicts with ${args.length} static arguments`);
+            const delta = firstServiceArgPos - args.length;
+            if (delta > 0) {
+                args = args.concat(( new Array(delta)));
+            }
+            else {
+                args = args.slice(0, firstServiceArgPos);
+            }
+        }
+        return Reflect.construct(ctor, args.concat(serviceArgs));
+    }
+    _setServiceInstance(id, instance) {
+        if (this._services.get(id) instanceof SyncDescriptor) {
+            this._services.set(id, instance);
+        }
+        else if (this._parent) {
+            this._parent._setServiceInstance(id, instance);
+        }
+        else {
+            throw new Error('illegalState - setting UNKNOWN service instance');
+        }
+    }
+    _getServiceInstanceOrDescriptor(id) {
+        const instanceOrDesc = this._services.get(id);
+        if (!instanceOrDesc && this._parent) {
+            return this._parent._getServiceInstanceOrDescriptor(id);
+        }
+        else {
+            return instanceOrDesc;
+        }
+    }
+    _getOrCreateServiceInstance(id, _trace) {
+        if (this._globalGraph && this._globalGraphImplicitDependency) {
+            this._globalGraph.insertEdge(this._globalGraphImplicitDependency, String(id));
+        }
+        const thing = this._getServiceInstanceOrDescriptor(id);
+        if (thing instanceof SyncDescriptor) {
+            return this._safeCreateAndCacheServiceInstance(id, thing, _trace.branch(id, true));
+        }
+        else {
+            _trace.branch(id, false);
+            return thing;
+        }
+    }
+    _safeCreateAndCacheServiceInstance(id, desc, _trace) {
+        if (( this._activeInstantiations.has(id))) {
+            throw new Error(`illegal state - RECURSIVELY instantiating service '${id}'`);
+        }
+        this._activeInstantiations.add(id);
+        try {
+            return this._createAndCacheServiceInstance(id, desc, _trace);
+        }
+        finally {
+            this._activeInstantiations.delete(id);
+        }
+    }
+    _createAndCacheServiceInstance(id, desc, _trace) {
+        const graph = ( new Graph(data => ( data.id.toString())));
+        let cycleCount = 0;
+        const stack = [{ id, desc, _trace }];
+        while (stack.length) {
+            const item = stack.pop();
+            graph.lookupOrInsertNode(item);
+            if (cycleCount++ > 1000) {
+                throw new CyclicDependencyError(graph);
+            }
+            for (const dependency of _util.getServiceDependencies(item.desc.ctor)) {
+                const instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);
+                if (!instanceOrDesc) {
+                    this._throwIfStrict(`[createInstance] ${id} depends on ${dependency.id} which is NOT registered.`, true);
+                }
+                this._globalGraph?.insertEdge(String(item.id), String(dependency.id));
+                if (instanceOrDesc instanceof SyncDescriptor) {
+                    const d = { id: dependency.id, desc: instanceOrDesc, _trace: item._trace.branch(dependency.id, true) };
+                    if (!graph.lookup(d)) {
+                        stack.push(d);
+                    }
+                    graph.insertEdge(item, d);
+                }
+            }
+        }
+        while (true) {
+            const roots = graph.roots();
+            if (roots.length === 0) {
+                if (!graph.isEmpty()) {
+                    throw new CyclicDependencyError(graph);
+                }
+                break;
+            }
+            for (const { data } of roots) {
+                const instanceOrDesc = this._getServiceInstanceOrDescriptor(data.id);
+                if (instanceOrDesc instanceof SyncDescriptor) {
+                    const instance = this._createServiceInstanceWithOwner(data.id, data.desc.ctor, data.desc.staticArguments, data.desc.supportsDelayedInstantiation, data._trace);
+                    this._setServiceInstance(data.id, instance);
+                }
+                graph.removeNode(data);
+            }
+        }
+        return this._getServiceInstanceOrDescriptor(id);
+    }
+    _createServiceInstanceWithOwner(id, ctor, args = [], supportsDelayedInstantiation, _trace) {
+        if (this._services.get(id) instanceof SyncDescriptor) {
+            return this._createServiceInstance(id, ctor, args, supportsDelayedInstantiation, _trace);
+        }
+        else if (this._parent) {
+            return this._parent._createServiceInstanceWithOwner(id, ctor, args, supportsDelayedInstantiation, _trace);
+        }
+        else {
+            throw new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`);
+        }
+    }
+    _createServiceInstance(id, ctor, args = [], supportsDelayedInstantiation, _trace) {
+        if (!supportsDelayedInstantiation) {
+            return this._createInstance(ctor, args, _trace);
+        }
+        else {
+            const child = ( new InstantiationService(undefined, this._strict, this, this._enableTracing));
+            child._globalGraphImplicitDependency = String(id);
+            const earlyListeners = ( new Map());
+            const idle = ( new GlobalIdleValue(() => {
+                const result = child._createInstance(ctor, args, _trace);
+                for (const [key, values] of earlyListeners) {
+                    const candidate = result[key];
+                    if (typeof candidate === 'function') {
+                        for (const listener of values) {
+                            candidate.apply(result, listener);
+                        }
+                    }
+                }
+                earlyListeners.clear();
+                return result;
+            }));
+            return ( new Proxy(Object.create(null), {
+                get(target, key) {
+                    if (!idle.isInitialized) {
+                        if (typeof key === 'string' && (key.startsWith('onDid') || key.startsWith('onWill'))) {
+                            let list = earlyListeners.get(key);
+                            if (!list) {
+                                list = ( new LinkedList());
+                                earlyListeners.set(key, list);
+                            }
+                            const event = (callback, thisArg, disposables) => {
+                                const rm = list.push([callback, thisArg, disposables]);
+                                return toDisposable(rm);
+                            };
+                            return event;
+                        }
+                    }
+                    if (key in target) {
+                        return target[key];
+                    }
+                    const obj = idle.value;
+                    let prop = obj[key];
+                    if (typeof prop !== 'function') {
+                        return prop;
+                    }
+                    prop = prop.bind(obj);
+                    target[key] = prop;
+                    return prop;
+                },
+                set(_target, p, value) {
+                    idle.value[p] = value;
+                    return true;
+                },
+                getPrototypeOf(_target) {
+                    return ctor.prototype;
+                }
+            }));
+        }
+    }
+    _throwIfStrict(msg, printWarning) {
+        if (printWarning) {
+            console.warn(msg);
+        }
+        if (this._strict) {
+            throw new Error(msg);
+        }
+    }
+}
+class Trace {
+    static { this.all = ( new Set()); }
+    static { this._None = new (class extends Trace {
+        constructor() { super(0 , null); }
+        stop() { }
+        branch() { return this; }
+    }); }
+    static traceInvocation(_enableTracing, ctor) {
+        return !_enableTracing ? Trace._None : ( new Trace(2 , ctor.name || ( new Error()).stack.split('\n').slice(3, 4).join('\n')));
+    }
+    static traceCreation(_enableTracing, ctor) {
+        return !_enableTracing ? Trace._None : ( new Trace(1 , ctor.name));
+    }
+    static { this._totals = 0; }
+    constructor(type, name) {
+        this.type = type;
+        this.name = name;
+        this._start = Date.now();
+        this._dep = [];
+    }
+    branch(id, first) {
+        const child = ( new Trace(3 , ( id.toString())));
+        this._dep.push([id, first, child]);
+        return child;
+    }
+    stop() {
+        const dur = Date.now() - this._start;
+        Trace._totals += dur;
+        let causedCreation = false;
+        function printChild(n, trace) {
+            const res = [];
+            const prefix = ( new Array(n + 1)).join('\t');
+            for (const [id, first, child] of trace._dep) {
+                if (first && child) {
+                    causedCreation = true;
+                    res.push(`${prefix}CREATES -> ${id}`);
+                    const nested = printChild(n + 1, child);
+                    if (nested) {
+                        res.push(nested);
+                    }
+                }
+                else {
+                    res.push(`${prefix}uses -> ${id}`);
+                }
+            }
+            return res.join('\n');
+        }
+        const lines = [
+            `${this.type === 1  ? 'CREATE' : 'CALL'} ${this.name}`,
+            `${printChild(1, this)}`,
+            `DONE, took ${dur.toFixed(2)}ms (grand total ${Trace._totals.toFixed(2)}ms)`
+        ];
+        if (dur > 2 || causedCreation) {
+            Trace.all.add(lines.join('\n'));
+        }
+    }
+}
+export { InstantiationService, Trace };

package/vscode/src/vs/platform/instantiation/common/serviceCollection.js

@@ -0,0 +1,20 @@
+class ServiceCollection {
+    constructor(...entries) {
+        this._entries = ( new Map());
+        for (const [id, service] of entries) {
+            this.set(id, service);
+        }
+    }
+    set(id, instanceOrDescriptor) {
+        const result = this._entries.get(id);
+        this._entries.set(id, instanceOrDescriptor);
+        return result;
+    }
+    has(id) {
+        return ( this._entries.has(id));
+    }
+    get(id) {
+        return this._entries.get(id);
+    }
+}
+export { ServiceCollection };

package/vscode/src/vs/platform/jsonschemas/common/jsonContributionRegistry.js

@@ -0,0 +1,33 @@
+import { Emitter } from '../../../base/common/event.js';
+import { Registry } from '../../registry/common/platform.js';
+const Extensions = {
+    JSONContribution: 'base.contributions.json'
+};
+function normalizeId(id) {
+    if (id.length > 0 && id.charAt(id.length - 1) === '#') {
+        return id.substring(0, id.length - 1);
+    }
+    return id;
+}
+class JSONContributionRegistry {
+    constructor() {
+        this._onDidChangeSchema = ( new Emitter());
+        this.onDidChangeSchema = this._onDidChangeSchema.event;
+        this.schemasById = {};
+    }
+    registerSchema(uri, unresolvedSchemaContent) {
+        this.schemasById[normalizeId(uri)] = unresolvedSchemaContent;
+        this._onDidChangeSchema.fire(uri);
+    }
+    notifySchemaChanged(uri) {
+        this._onDidChangeSchema.fire(uri);
+    }
+    getSchemaContributions() {
+        return {
+            schemas: this.schemasById,
+        };
+    }
+}
+const jsonContributionRegistry = ( new JSONContributionRegistry());
+Registry.add(Extensions.JSONContribution, jsonContributionRegistry);
+export { Extensions };