@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/platform/terminal/common/capabilities/terminalCapabilityStore.js

@@ -0,0 +1,80 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class TerminalCapabilityStore extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._map = ( new Map());
+        this._onDidRemoveCapability = this._register(( new Emitter()));
+        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
+        this._onDidAddCapability = this._register(( new Emitter()));
+        this.onDidAddCapability = this._onDidAddCapability.event;
+    }
+    get items() {
+        return ( this._map.keys());
+    }
+    add(capability, impl) {
+        this._map.set(capability, impl);
+        this._onDidAddCapability.fire(capability);
+    }
+    get(capability) {
+        return this._map.get(capability);
+    }
+    remove(capability) {
+        if (!( this._map.has(capability))) {
+            return;
+        }
+        this._map.delete(capability);
+        this._onDidRemoveCapability.fire(capability);
+    }
+    has(capability) {
+        return ( this._map.has(capability));
+    }
+}
+class TerminalCapabilityStoreMultiplexer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._stores = [];
+        this._onDidRemoveCapability = this._register(( new Emitter()));
+        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
+        this._onDidAddCapability = this._register(( new Emitter()));
+        this.onDidAddCapability = this._onDidAddCapability.event;
+    }
+    get items() {
+        return this._items();
+    }
+    *_items() {
+        for (const store of this._stores) {
+            for (const c of store.items) {
+                yield c;
+            }
+        }
+    }
+    has(capability) {
+        for (const store of this._stores) {
+            for (const c of store.items) {
+                if (c === capability) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    get(capability) {
+        for (const store of this._stores) {
+            const c = store.get(capability);
+            if (c) {
+                return c;
+            }
+        }
+        return undefined;
+    }
+    add(store) {
+        this._stores.push(store);
+        for (const capability of store.items) {
+            this._onDidAddCapability.fire(capability);
+        }
+        store.onDidAddCapability(e => this._onDidAddCapability.fire(e));
+        store.onDidRemoveCapability(e => this._onDidRemoveCapability.fire(e));
+    }
+}
+export { TerminalCapabilityStore, TerminalCapabilityStoreMultiplexer };

package/dist/vscode/vs/platform/terminal/common/environmentVariable.js

@@ -0,0 +1,7 @@
+var EnvironmentVariableMutatorType;
+( (function(EnvironmentVariableMutatorType) {
+    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Replace"] = 1] = "Replace";
+    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Append"] = 2] = "Append";
+    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Prepend"] = 3] = "Prepend";
+})(EnvironmentVariableMutatorType || (EnvironmentVariableMutatorType = {})));
+export { EnvironmentVariableMutatorType };

package/dist/vscode/vs/platform/terminal/common/environmentVariableCollection.js

@@ -0,0 +1,196 @@
+import { isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { EnvironmentVariableMutatorType } from './environmentVariable.js';
+const mutatorTypeToLabelMap = ( new Map([
+    [EnvironmentVariableMutatorType.Append, 'APPEND'],
+    [EnvironmentVariableMutatorType.Prepend, 'PREPEND'],
+    [EnvironmentVariableMutatorType.Replace, 'REPLACE']
+]));
+class MergedEnvironmentVariableCollection {
+    constructor(collections) {
+        this.collections = collections;
+        this.map = ( new Map());
+        this.descriptionMap = ( new Map());
+        collections.forEach((collection, extensionIdentifier) => {
+            this.populateDescriptionMap(collection, extensionIdentifier);
+            const it = collection.map.entries();
+            let next = it.next();
+            while (!next.done) {
+                const mutator = next.value[1];
+                const key = next.value[0];
+                let entry = this.map.get(key);
+                if (!entry) {
+                    entry = [];
+                    this.map.set(key, entry);
+                }
+                if (entry.length > 0 && entry[0].type === EnvironmentVariableMutatorType.Replace) {
+                    next = it.next();
+                    continue;
+                }
+                const extensionMutator = {
+                    extensionIdentifier,
+                    value: mutator.value,
+                    type: mutator.type,
+                    scope: mutator.scope,
+                    variable: mutator.variable,
+                    options: mutator.options
+                };
+                if (!extensionMutator.scope) {
+                    delete extensionMutator.scope;
+                }
+                entry.unshift(extensionMutator);
+                next = it.next();
+            }
+        });
+    }
+    async applyToProcessEnvironment(env, scope, variableResolver) {
+        let lowerToActualVariableNames;
+        if (isWindows) {
+            lowerToActualVariableNames = {};
+            ( Object.keys(env)).forEach(e => lowerToActualVariableNames[e.toLowerCase()] = e);
+        }
+        for (const [variable, mutators] of this.getVariableMap(scope)) {
+            const actualVariable = isWindows ? lowerToActualVariableNames[variable.toLowerCase()] || variable : variable;
+            for (const mutator of mutators) {
+                const value = variableResolver ? await variableResolver(mutator.value) : mutator.value;
+                if (mutator.options?.applyAtProcessCreation ?? true) {
+                    switch (mutator.type) {
+                        case EnvironmentVariableMutatorType.Append:
+                            env[actualVariable] = (env[actualVariable] || '') + value;
+                            break;
+                        case EnvironmentVariableMutatorType.Prepend:
+                            env[actualVariable] = value + (env[actualVariable] || '');
+                            break;
+                        case EnvironmentVariableMutatorType.Replace:
+                            env[actualVariable] = value;
+                            break;
+                    }
+                }
+                if (mutator.options?.applyAtShellIntegration ?? false) {
+                    const key = `VSCODE_ENV_${mutatorTypeToLabelMap.get(mutator.type)}`;
+                    env[key] = (env[key] ? env[key] + ':' : '') + variable + '=' + this._encodeColons(value);
+                }
+            }
+        }
+    }
+    _encodeColons(value) {
+        return value.replaceAll(':', '\\x3a');
+    }
+    diff(other, scope) {
+        const added = ( new Map());
+        const changed = ( new Map());
+        const removed = ( new Map());
+        other.getVariableMap(scope).forEach((otherMutators, variable) => {
+            const currentMutators = this.getVariableMap(scope).get(variable);
+            const result = getMissingMutatorsFromArray(otherMutators, currentMutators);
+            if (result) {
+                added.set(variable, result);
+            }
+        });
+        this.getVariableMap(scope).forEach((currentMutators, variable) => {
+            const otherMutators = other.getVariableMap(scope).get(variable);
+            const result = getMissingMutatorsFromArray(currentMutators, otherMutators);
+            if (result) {
+                removed.set(variable, result);
+            }
+        });
+        this.getVariableMap(scope).forEach((currentMutators, variable) => {
+            const otherMutators = other.getVariableMap(scope).get(variable);
+            const result = getChangedMutatorsFromArray(currentMutators, otherMutators);
+            if (result) {
+                changed.set(variable, result);
+            }
+        });
+        if (added.size === 0 && changed.size === 0 && removed.size === 0) {
+            return undefined;
+        }
+        return { added, changed, removed };
+    }
+    getVariableMap(scope) {
+        const result = ( new Map());
+        this.map.forEach((mutators, _key) => {
+            const filteredMutators = mutators.filter(m => filterScope(m, scope));
+            if (filteredMutators.length > 0) {
+                result.set(filteredMutators[0].variable, filteredMutators);
+            }
+        });
+        return result;
+    }
+    getDescriptionMap(scope) {
+        const result = ( new Map());
+        this.descriptionMap.forEach((mutators, _key) => {
+            const filteredMutators = mutators.filter(m => filterScope(m, scope, true));
+            if (filteredMutators.length > 0) {
+                result.set(filteredMutators[0].extensionIdentifier, filteredMutators[0].description);
+            }
+        });
+        return result;
+    }
+    populateDescriptionMap(collection, extensionIdentifier) {
+        if (!collection.descriptionMap) {
+            return;
+        }
+        const it = collection.descriptionMap.entries();
+        let next = it.next();
+        while (!next.done) {
+            const mutator = next.value[1];
+            const key = next.value[0];
+            let entry = this.descriptionMap.get(key);
+            if (!entry) {
+                entry = [];
+                this.descriptionMap.set(key, entry);
+            }
+            const extensionMutator = {
+                extensionIdentifier,
+                scope: mutator.scope,
+                description: mutator.description
+            };
+            if (!extensionMutator.scope) {
+                delete extensionMutator.scope;
+            }
+            entry.push(extensionMutator);
+            next = it.next();
+        }
+    }
+}
+function filterScope(mutator, scope, strictFilter = false) {
+    if (!mutator.scope) {
+        if (strictFilter) {
+            return scope === mutator.scope;
+        }
+        return true;
+    }
+    if (mutator.scope.workspaceFolder && scope?.workspaceFolder && mutator.scope.workspaceFolder.index === scope.workspaceFolder.index) {
+        return true;
+    }
+    return false;
+}
+function getMissingMutatorsFromArray(current, other) {
+    if (!other) {
+        return current;
+    }
+    const otherMutatorExtensions = ( new Set());
+    other.forEach(m => otherMutatorExtensions.add(m.extensionIdentifier));
+    const result = [];
+    current.forEach(mutator => {
+        if (!( otherMutatorExtensions.has(mutator.extensionIdentifier))) {
+            result.push(mutator);
+        }
+    });
+    return result.length === 0 ? undefined : result;
+}
+function getChangedMutatorsFromArray(current, other) {
+    if (!other) {
+        return undefined;
+    }
+    const otherMutatorExtensions = ( new Map());
+    other.forEach(m => otherMutatorExtensions.set(m.extensionIdentifier, m));
+    const result = [];
+    current.forEach(mutator => {
+        const otherMutator = otherMutatorExtensions.get(mutator.extensionIdentifier);
+        if (otherMutator && (mutator.type !== otherMutator.type || mutator.value !== otherMutator.value || mutator.scope?.workspaceFolder?.index !== otherMutator.scope?.workspaceFolder?.index)) {
+            result.push(otherMutator);
+        }
+    });
+    return result.length === 0 ? undefined : result;
+}
+export { MergedEnvironmentVariableCollection };

package/dist/vscode/vs/platform/terminal/common/environmentVariableShared.js

@@ -0,0 +1,23 @@
+function serializeEnvironmentVariableCollection(collection) {
+    return [...collection.entries()];
+}
+function serializeEnvironmentDescriptionMap(descriptionMap) {
+    return descriptionMap ? [...descriptionMap.entries()] : [];
+}
+function deserializeEnvironmentVariableCollection(serializedCollection) {
+    return ( new Map(serializedCollection));
+}
+function deserializeEnvironmentDescriptionMap(serializableEnvironmentDescription) {
+    return ( new Map(serializableEnvironmentDescription ?? []));
+}
+function serializeEnvironmentVariableCollections(collections) {
+    return ( Array.from(collections.entries()).map(e => {
+        return [e[0], serializeEnvironmentVariableCollection(e[1].map), serializeEnvironmentDescriptionMap(e[1].descriptionMap)];
+    }));
+}
+function deserializeEnvironmentVariableCollections(serializedCollection) {
+    return ( new Map(( serializedCollection.map(e => {
+        return [e[0], { map: deserializeEnvironmentVariableCollection(e[1]), descriptionMap: deserializeEnvironmentDescriptionMap(e[2]) }];
+    }))));
+}
+export { deserializeEnvironmentDescriptionMap, deserializeEnvironmentVariableCollection, deserializeEnvironmentVariableCollections, serializeEnvironmentDescriptionMap, serializeEnvironmentVariableCollection, serializeEnvironmentVariableCollections };

package/dist/vscode/vs/platform/terminal/common/terminal.js

@@ -1,3 +1,23 @@
 import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 const terminalTabFocusContextKey = ( new RawContextKey('terminalTabFocusMode', false, true));
-export { terminalTabFocusContextKey };
+var TitleEventSource;
+( (function(TitleEventSource) {
+    TitleEventSource[TitleEventSource["Api"] = 0] = "Api";
+    TitleEventSource[TitleEventSource["Process"] = 1] = "Process";
+    TitleEventSource[TitleEventSource["Sequence"] = 2] = "Sequence";
+    TitleEventSource[TitleEventSource["Config"] = 3] = "Config";
+})(TitleEventSource || (TitleEventSource = {})));
+var TerminalLocation;
+( (function(TerminalLocation) {
+    TerminalLocation[TerminalLocation["Panel"] = 1] = "Panel";
+    TerminalLocation[TerminalLocation["Editor"] = 2] = "Editor";
+})(TerminalLocation || (TerminalLocation = {})));
+var TerminalExitReason;
+( (function(TerminalExitReason) {
+    TerminalExitReason[TerminalExitReason["Unknown"] = 0] = "Unknown";
+    TerminalExitReason[TerminalExitReason["Shutdown"] = 1] = "Shutdown";
+    TerminalExitReason[TerminalExitReason["Process"] = 2] = "Process";
+    TerminalExitReason[TerminalExitReason["User"] = 3] = "User";
+    TerminalExitReason[TerminalExitReason["Extension"] = 4] = "Extension";
+})(TerminalExitReason || (TerminalExitReason = {})));
+export { TerminalExitReason, TerminalLocation, TitleEventSource, terminalTabFocusContextKey };

package/dist/vscode/vs/platform/terminal/common/terminalDataBuffering.js

@@ -0,0 +1,45 @@
+class TerminalDataBufferer {
+    constructor(_callback) {
+        this._callback = _callback;
+        this._terminalBufferMap = ( new Map());
+    }
+    dispose() {
+        for (const buffer of ( this._terminalBufferMap.values())) {
+            buffer.dispose();
+        }
+    }
+    startBuffering(id, event, throttleBy = 5) {
+        const disposable = event((e) => {
+            const data = (typeof e === 'string' ? e : e.data);
+            let buffer = this._terminalBufferMap.get(id);
+            if (buffer) {
+                buffer.data.push(data);
+                return;
+            }
+            const timeoutId = setTimeout(() => this.flushBuffer(id), throttleBy);
+            buffer = {
+                data: [data],
+                timeoutId: timeoutId,
+                dispose: () => {
+                    clearTimeout(timeoutId);
+                    this.flushBuffer(id);
+                    disposable.dispose();
+                }
+            };
+            this._terminalBufferMap.set(id, buffer);
+        });
+        return disposable;
+    }
+    stopBuffering(id) {
+        const buffer = this._terminalBufferMap.get(id);
+        buffer?.dispose();
+    }
+    flushBuffer(id) {
+        const buffer = this._terminalBufferMap.get(id);
+        if (buffer) {
+            this._terminalBufferMap.delete(id);
+            this._callback(id, buffer.data.join(''));
+        }
+    }
+}
+export { TerminalDataBufferer };

package/dist/vscode/vs/platform/terminal/common/terminalEnvironment.js

@@ -0,0 +1,37 @@
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+function escapeNonWindowsPath(path) {
+    let newPath = path;
+    if (newPath.includes('\\')) {
+        newPath = newPath.replace(/\\/g, '\\\\');
+    }
+    const bannedChars = /[\`\$\|\&\>\~\#\!\^\*\;\<\"\']/g;
+    newPath = newPath.replace(bannedChars, '');
+    return `'${newPath}'`;
+}
+function collapseTildePath(path, userHome, separator) {
+    if (!path) {
+        return '';
+    }
+    if (!userHome) {
+        return path;
+    }
+    if (userHome.match(/[\/\\]$/)) {
+        userHome = userHome.slice(0, userHome.length - 1);
+    }
+    const normalizedPath = path.replace(/\\/g, '/').toLowerCase();
+    const normalizedUserHome = userHome.replace(/\\/g, '/').toLowerCase();
+    if (!normalizedPath.includes(normalizedUserHome)) {
+        return path;
+    }
+    return `~${separator}${path.slice(userHome.length + 1)}`;
+}
+function sanitizeCwd(cwd) {
+    if (cwd.match(/^['"].*['"]$/)) {
+        cwd = cwd.substring(1, cwd.length - 1);
+    }
+    if (OS === 1  && cwd && cwd[1] === ':') {
+        return cwd[0].toUpperCase() + cwd.substring(1);
+    }
+    return cwd;
+}
+export { collapseTildePath, escapeNonWindowsPath, sanitizeCwd };