@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/api/common/extHostSecrets.js

@@ -0,0 +1,29 @@
+import { __classPrivateFieldSet, __classPrivateFieldGet } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+var _ExtensionSecrets_secretState;
+class ExtensionSecrets {
+    constructor(extensionDescription, secretState) {
+        _ExtensionSecrets_secretState.set(this, void 0);
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._id = ExtensionIdentifier.toKey(extensionDescription.identifier);
+        __classPrivateFieldSet(this, _ExtensionSecrets_secretState, secretState, "f");
+        __classPrivateFieldGet(this, _ExtensionSecrets_secretState, "f").onDidChangePassword(e => {
+            if (e.extensionId === this._id) {
+                this._onDidChange.fire({ key: e.key });
+            }
+        });
+    }
+    get(key) {
+        return __classPrivateFieldGet(this, _ExtensionSecrets_secretState, "f").get(this._id, key);
+    }
+    store(key, value) {
+        return __classPrivateFieldGet(this, _ExtensionSecrets_secretState, "f").store(this._id, key, value);
+    }
+    delete(key) {
+        return __classPrivateFieldGet(this, _ExtensionSecrets_secretState, "f").delete(this._id, key);
+    }
+}
+_ExtensionSecrets_secretState = ( new WeakMap());
+export { ExtensionSecrets };

package/dist/vscode/vs/workbench/api/common/extHostStorage.js

@@ -0,0 +1,42 @@
+import { MainContext } from './extHost.protocol.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+class ExtHostStorage {
+    constructor(mainContext, _logService) {
+        this._logService = _logService;
+        this._onDidChangeStorage = ( new Emitter());
+        this.onDidChangeStorage = this._onDidChangeStorage.event;
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadStorage));
+    }
+    registerExtensionStorageKeysToSync(extension, keys) {
+        this._proxy.$registerExtensionStorageKeysToSync(extension, keys);
+    }
+    async initializeExtensionStorage(shared, key, defaultValue) {
+        const value = await this._proxy.$initializeExtensionStorage(shared, key);
+        let parsedValue;
+        if (value) {
+            parsedValue = this.safeParseValue(shared, key, value);
+        }
+        return parsedValue || defaultValue;
+    }
+    setValue(shared, key, value) {
+        return this._proxy.$setValue(shared, key, value);
+    }
+    $acceptValue(shared, key, value) {
+        const parsedValue = this.safeParseValue(shared, key, value);
+        if (parsedValue) {
+            this._onDidChangeStorage.fire({ shared, key, value: parsedValue });
+        }
+    }
+    safeParseValue(shared, key, value) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            this._logService.error(`[extHostStorage] unexpected error parsing storage contents (extensionId: ${key}, global: ${shared}): ${error}`);
+        }
+        return undefined;
+    }
+}
+const IExtHostStorage = ( createDecorator('IExtHostStorage'));
+export { ExtHostStorage, IExtHostStorage };

package/dist/vscode/vs/workbench/api/common/extHostStoragePaths.js

@@ -0,0 +1,64 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IExtHostConsumerFileSystem } from './extHostFileSystemConsumer.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+const IExtensionStoragePaths = ( createDecorator('IExtensionStoragePaths'));
+let ExtensionStoragePaths = class ExtensionStoragePaths {
+    constructor(initData, _logService, _extHostFileSystem) {
+        this._logService = _logService;
+        this._extHostFileSystem = _extHostFileSystem;
+        this._workspace = initData.workspace ?? undefined;
+        this._environment = initData.environment;
+        this.whenReady = this._getOrCreateWorkspaceStoragePath().then(value => this._value = value);
+    }
+    async _getWorkspaceStorageURI(storageName) {
+        return URI.joinPath(this._environment.workspaceStorageHome, storageName);
+    }
+    async _getOrCreateWorkspaceStoragePath() {
+        if (!this._workspace) {
+            return Promise.resolve(undefined);
+        }
+        const storageName = this._workspace.id;
+        const storageUri = await this._getWorkspaceStorageURI(storageName);
+        try {
+            await this._extHostFileSystem.value.stat(storageUri);
+            this._logService.trace('[ExtHostStorage] storage dir already exists', storageUri);
+            return storageUri;
+        }
+        catch {
+        }
+        try {
+            this._logService.trace('[ExtHostStorage] creating dir and metadata-file', storageUri);
+            await this._extHostFileSystem.value.createDirectory(storageUri);
+            await this._extHostFileSystem.value.writeFile(URI.joinPath(storageUri, 'meta.json'), ( new TextEncoder()).encode(JSON.stringify({
+                id: this._workspace.id,
+                configuration: URI.revive(this._workspace.configuration)?.toString(),
+                name: this._workspace.name
+            }, undefined, 2)));
+            return storageUri;
+        }
+        catch (e) {
+            this._logService.error('[ExtHostStorage]', e);
+            return undefined;
+        }
+    }
+    workspaceValue(extension) {
+        if (this._value) {
+            return URI.joinPath(this._value, extension.identifier.value);
+        }
+        return undefined;
+    }
+    globalValue(extension) {
+        return URI.joinPath(this._environment.globalStorageHome, extension.identifier.value.toLowerCase());
+    }
+    onWillDeactivateAll() {
+    }
+};
+ExtensionStoragePaths = ( __decorate([
+    ( __param(0, IExtHostInitDataService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IExtHostConsumerFileSystem))
+], ExtensionStoragePaths));
+export { ExtensionStoragePaths, IExtensionStoragePaths };

package/dist/vscode/vs/workbench/api/common/extHostTelemetry.js

@@ -0,0 +1,266 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { isLogLevel, LogLevel, ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { UIKind } from '../../services/extensions/common/extensionHostProtocol.js';
+import { getRemoteName } from 'monaco-editor/esm/vs/platform/remote/common/remoteHosts.js';
+import { extensionTelemetryLogChannelId, cleanRemoteAuthority, cleanData } from '../../../platform/telemetry/common/telemetryUtils.js';
+import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+let ExtHostTelemetry = class ExtHostTelemetry extends Disposable {
+    constructor(initData, loggerService) {
+        super();
+        this.initData = initData;
+        this.loggerService = loggerService;
+        this._onDidChangeTelemetryEnabled = this._register(( new Emitter()));
+        this.onDidChangeTelemetryEnabled = this._onDidChangeTelemetryEnabled.event;
+        this._onDidChangeTelemetryConfiguration = this._register(( new Emitter()));
+        this.onDidChangeTelemetryConfiguration = this._onDidChangeTelemetryConfiguration.event;
+        this._productConfig = { usage: true, error: true };
+        this._level = 0 ;
+        this._telemetryIsSupported = false;
+        this._inLoggingOnlyMode = false;
+        this._telemetryLoggers = ( new Map());
+        this.extHostTelemetryLogFile = URI.revive(this.initData.environment.extensionTelemetryLogResource);
+        this._inLoggingOnlyMode = this.initData.environment.isExtensionTelemetryLoggingOnly;
+        this._outputLogger = loggerService.createLogger(this.extHostTelemetryLogFile, { id: extensionTelemetryLogChannelId, name: ( localize(
+            'extensionTelemetryLog',
+            "Extension Telemetry{0}",
+            this._inLoggingOnlyMode ? ' (Not Sent)' : ''
+        )), hidden: true });
+        this._register(loggerService.onDidChangeLogLevel(arg => {
+            if (isLogLevel(arg)) {
+                this.updateLoggerVisibility();
+            }
+        }));
+        this._outputLogger.info('Below are logs for extension telemetry events sent to the telemetry output channel API once the log level is set to trace.');
+        this._outputLogger.info('===========================================================');
+    }
+    updateLoggerVisibility() {
+        this.loggerService.setVisibility(this.extHostTelemetryLogFile, this._telemetryIsSupported && this.loggerService.getLogLevel() === LogLevel.Trace);
+    }
+    getTelemetryConfiguration() {
+        return this._level === 3 ;
+    }
+    getTelemetryDetails() {
+        return {
+            isCrashEnabled: this._level >= 1 ,
+            isErrorsEnabled: this._productConfig.error ? this._level >= 2  : false,
+            isUsageEnabled: this._productConfig.usage ? this._level >= 3  : false
+        };
+    }
+    instantiateLogger(extension, sender, options) {
+        const telemetryDetails = this.getTelemetryDetails();
+        const logger = ( new ExtHostTelemetryLogger(
+            sender,
+            options,
+            extension,
+            this._outputLogger,
+            this._inLoggingOnlyMode,
+            this.getBuiltInCommonProperties(extension),
+            { isUsageEnabled: telemetryDetails.isUsageEnabled, isErrorsEnabled: telemetryDetails.isErrorsEnabled }
+        ));
+        const loggers = this._telemetryLoggers.get(extension.identifier.value) ?? [];
+        this._telemetryLoggers.set(extension.identifier.value, [...loggers, logger]);
+        return logger.apiTelemetryLogger;
+    }
+    $initializeTelemetryLevel(level, supportsTelemetry, productConfig) {
+        this._level = level;
+        this._telemetryIsSupported = supportsTelemetry;
+        this._productConfig = productConfig ?? { usage: true, error: true };
+        this.updateLoggerVisibility();
+    }
+    getBuiltInCommonProperties(extension) {
+        const commonProperties = Object.create(null);
+        commonProperties['common.extname'] = `${extension.publisher}.${extension.name}`;
+        commonProperties['common.extversion'] = extension.version;
+        commonProperties['common.vscodemachineid'] = this.initData.telemetryInfo.machineId;
+        commonProperties['common.vscodesessionid'] = this.initData.telemetryInfo.sessionId;
+        commonProperties['common.vscodeversion'] = this.initData.version;
+        commonProperties['common.isnewappinstall'] = isNewAppInstall(this.initData.telemetryInfo.firstSessionDate);
+        commonProperties['common.product'] = this.initData.environment.appHost;
+        switch (this.initData.uiKind) {
+            case UIKind.Web:
+                commonProperties['common.uikind'] = 'web';
+                break;
+            case UIKind.Desktop:
+                commonProperties['common.uikind'] = 'desktop';
+                break;
+            default:
+                commonProperties['common.uikind'] = 'unknown';
+        }
+        commonProperties['common.remotename'] = getRemoteName(cleanRemoteAuthority(this.initData.remote.authority));
+        return commonProperties;
+    }
+    $onDidChangeTelemetryLevel(level) {
+        this._oldTelemetryEnablement = this.getTelemetryConfiguration();
+        this._level = level;
+        const telemetryDetails = this.getTelemetryDetails();
+        this._telemetryLoggers.forEach((loggers, key) => {
+            const newLoggers = loggers.filter(l => !l.isDisposed);
+            if (newLoggers.length === 0) {
+                this._telemetryLoggers.delete(key);
+            }
+            else {
+                this._telemetryLoggers.set(key, newLoggers);
+            }
+        });
+        this._telemetryLoggers.forEach(loggers => {
+            for (const logger of loggers) {
+                logger.updateTelemetryEnablements(telemetryDetails.isUsageEnabled, telemetryDetails.isErrorsEnabled);
+            }
+        });
+        if (this._oldTelemetryEnablement !== this.getTelemetryConfiguration()) {
+            this._onDidChangeTelemetryEnabled.fire(this.getTelemetryConfiguration());
+        }
+        this._onDidChangeTelemetryConfiguration.fire(this.getTelemetryDetails());
+        this.updateLoggerVisibility();
+    }
+    onExtensionError(extension, error) {
+        const loggers = this._telemetryLoggers.get(extension.value);
+        const nonDisposedLoggers = loggers?.filter(l => !l.isDisposed);
+        if (!nonDisposedLoggers) {
+            this._telemetryLoggers.delete(extension.value);
+            return false;
+        }
+        let errorEmitted = false;
+        for (const logger of nonDisposedLoggers) {
+            if (logger.ignoreUnhandledExtHostErrors) {
+                continue;
+            }
+            logger.logError(error);
+            errorEmitted = true;
+        }
+        return errorEmitted;
+    }
+};
+ExtHostTelemetry = ( __decorate([
+    ( __param(0, IExtHostInitDataService)),
+    ( __param(1, ILoggerService))
+], ExtHostTelemetry));
+class ExtHostTelemetryLogger {
+    static validateSender(sender) {
+        if (typeof sender !== 'object') {
+            throw new TypeError('TelemetrySender argument is invalid');
+        }
+        if (typeof sender.sendEventData !== 'function') {
+            throw new TypeError('TelemetrySender.sendEventData must be a function');
+        }
+        if (typeof sender.sendErrorData !== 'function') {
+            throw new TypeError('TelemetrySender.sendErrorData must be a function');
+        }
+        if (typeof sender.flush !== 'undefined' && typeof sender.flush !== 'function') {
+            throw new TypeError('TelemetrySender.flush must be a function or undefined');
+        }
+    }
+    constructor(sender, options, _extension, _logger, _inLoggingOnlyMode, _commonProperties, telemetryEnablements) {
+        this._extension = _extension;
+        this._logger = _logger;
+        this._inLoggingOnlyMode = _inLoggingOnlyMode;
+        this._commonProperties = _commonProperties;
+        this._onDidChangeEnableStates = ( new Emitter());
+        this.ignoreUnhandledExtHostErrors = options?.ignoreUnhandledErrors ?? false;
+        this._ignoreBuiltinCommonProperties = options?.ignoreBuiltInCommonProperties ?? false;
+        this._additionalCommonProperties = options?.additionalCommonProperties;
+        this._sender = sender;
+        this._telemetryEnablements = { isUsageEnabled: telemetryEnablements.isUsageEnabled, isErrorsEnabled: telemetryEnablements.isErrorsEnabled };
+    }
+    updateTelemetryEnablements(isUsageEnabled, isErrorsEnabled) {
+        if (this._apiObject) {
+            this._telemetryEnablements = { isUsageEnabled, isErrorsEnabled };
+            this._onDidChangeEnableStates.fire(this._apiObject);
+        }
+    }
+    mixInCommonPropsAndCleanData(data) {
+        let updatedData = 'properties' in data ? (data.properties ?? {}) : data;
+        updatedData = cleanData(updatedData, []);
+        if (this._additionalCommonProperties) {
+            updatedData = mixin(updatedData, this._additionalCommonProperties);
+        }
+        if (!this._ignoreBuiltinCommonProperties) {
+            updatedData = mixin(updatedData, this._commonProperties);
+        }
+        if ('properties' in data) {
+            data.properties = updatedData;
+        }
+        else {
+            data = updatedData;
+        }
+        return data;
+    }
+    logEvent(eventName, data) {
+        if (!this._sender) {
+            return;
+        }
+        if (this._extension.publisher === 'vscode') {
+            eventName = this._extension.name + '/' + eventName;
+        }
+        else {
+            eventName = this._extension.identifier.value + '/' + eventName;
+        }
+        data = this.mixInCommonPropsAndCleanData(data || {});
+        if (!this._inLoggingOnlyMode) {
+            this._sender?.sendEventData(eventName, data);
+        }
+        this._logger.trace(eventName, data);
+    }
+    logUsage(eventName, data) {
+        if (!this._telemetryEnablements.isUsageEnabled) {
+            return;
+        }
+        this.logEvent(eventName, data);
+    }
+    logError(eventNameOrException, data) {
+        if (!this._telemetryEnablements.isErrorsEnabled || !this._sender) {
+            return;
+        }
+        if (typeof eventNameOrException === 'string') {
+            this.logEvent(eventNameOrException, data);
+        }
+        else {
+            this._sender.sendErrorData(eventNameOrException, data);
+        }
+    }
+    get apiTelemetryLogger() {
+        if (!this._apiObject) {
+            const that = this;
+            const obj = {
+                logUsage: that.logUsage.bind(that),
+                get isUsageEnabled() {
+                    return that._telemetryEnablements.isUsageEnabled;
+                },
+                get isErrorsEnabled() {
+                    return that._telemetryEnablements.isErrorsEnabled;
+                },
+                logError: that.logError.bind(that),
+                dispose: that.dispose.bind(that),
+                onDidChangeEnableStates: that._onDidChangeEnableStates.event.bind(that)
+            };
+            this._apiObject = ( Object.freeze(obj));
+        }
+        return this._apiObject;
+    }
+    get isDisposed() {
+        return !this._sender;
+    }
+    dispose() {
+        if (this._sender?.flush) {
+            let tempSender = this._sender;
+            this._sender = undefined;
+            Promise.resolve(tempSender.flush()).then(tempSender = undefined);
+            this._apiObject = undefined;
+        }
+        else {
+            this._sender = undefined;
+        }
+    }
+}
+function isNewAppInstall(firstSessionDate) {
+    const installAge = Date.now() - ( new Date(firstSessionDate)).getTime();
+    return isNaN(installAge) ? false : installAge < 1000 * 60 * 60 * 24;
+}
+const IExtHostTelemetry = ( createDecorator('IExtHostTelemetry'));
+export { ExtHostTelemetry, ExtHostTelemetryLogger, IExtHostTelemetry, isNewAppInstall };

package/dist/vscode/vs/workbench/api/common/extHostTerminalService.js

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

package/dist/vscode/vs/workbench/api/common/extHostTestItem.js

@@ -0,0 +1,122 @@
+import * as editorRange from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { createPrivateApiFor, getPrivateApiFor } from './extHostTestingPrivateApi.js';
+import { createTestItemChildren } from '../../contrib/testing/common/testItemCollection.js';
+import { TestTag, Range, MarkdownString } from './extHostTypeConverters.js';
+const testItemPropAccessor = (api, defaultValue, equals, toUpdate) => {
+    let value = defaultValue;
+    return {
+        enumerable: true,
+        configurable: false,
+        get() {
+            return value;
+        },
+        set(newValue) {
+            if (!equals(value, newValue)) {
+                const oldValue = value;
+                value = newValue;
+                api.listener?.(toUpdate(newValue, oldValue));
+            }
+        },
+    };
+};
+const strictEqualComparator = (a, b) => a === b;
+const propComparators = {
+    range: (a, b) => {
+        if (a === b) {
+            return true;
+        }
+        if (!a || !b) {
+            return false;
+        }
+        return a.isEqual(b);
+    },
+    label: strictEqualComparator,
+    description: strictEqualComparator,
+    sortText: strictEqualComparator,
+    busy: strictEqualComparator,
+    error: strictEqualComparator,
+    canResolveChildren: strictEqualComparator,
+    tags: (a, b) => {
+        if (a.length !== b.length) {
+            return false;
+        }
+        if (( a.some(t1 => !b.find(t2 => t1.id === t2.id)))) {
+            return false;
+        }
+        return true;
+    },
+};
+const evSetProps = (fn) => v => ({ op: 4 , update: fn(v) });
+const makePropDescriptors = (api, label) => ({
+    range: (() => {
+        let value;
+        const updateProps = evSetProps(r => ({ range: editorRange.Range.lift(Range.from(r)) }));
+        return {
+            enumerable: true,
+            configurable: false,
+            get() {
+                return value;
+            },
+            set(newValue) {
+                api.listener?.({ op: 6  });
+                if (!propComparators.range(value, newValue)) {
+                    value = newValue;
+                    api.listener?.(updateProps(newValue));
+                }
+            },
+        };
+    })(),
+    label: testItemPropAccessor(api, label, propComparators.label, evSetProps(label => ({ label }))),
+    description: testItemPropAccessor(api, undefined, propComparators.description, evSetProps(description => ({ description }))),
+    sortText: testItemPropAccessor(api, undefined, propComparators.sortText, evSetProps(sortText => ({ sortText }))),
+    canResolveChildren: testItemPropAccessor(api, false, propComparators.canResolveChildren, state => ({
+        op: 2 ,
+        state,
+    })),
+    busy: testItemPropAccessor(api, false, propComparators.busy, evSetProps(busy => ({ busy }))),
+    error: testItemPropAccessor(api, undefined, propComparators.error, evSetProps(error => ({ error: MarkdownString.fromStrict(error) || null }))),
+    tags: testItemPropAccessor(api, [], propComparators.tags, (current, previous) => ({
+        op: 1 ,
+        new: ( current.map(TestTag.from)),
+        old: ( previous.map(TestTag.from)),
+    })),
+});
+class TestItemImpl {
+    constructor(controllerId, id, label, uri) {
+        if (id.includes("\0" )) {
+            throw new Error(`Test IDs may not include the ${JSON.stringify(id)} symbol`);
+        }
+        const api = createPrivateApiFor(this, controllerId);
+        Object.defineProperties(this, {
+            id: {
+                value: id,
+                enumerable: true,
+                writable: false,
+            },
+            uri: {
+                value: uri,
+                enumerable: true,
+                writable: false,
+            },
+            parent: {
+                enumerable: false,
+                get() {
+                    return api.parent instanceof TestItemRootImpl ? undefined : api.parent;
+                },
+            },
+            children: {
+                value: createTestItemChildren(api, getPrivateApiFor, TestItemImpl),
+                enumerable: true,
+                writable: false,
+            },
+            ...makePropDescriptors(api, label),
+        });
+    }
+}
+class TestItemRootImpl extends TestItemImpl {
+    constructor(controllerId, label) {
+        super(controllerId, controllerId, label, undefined);
+        this._isRoot = true;
+    }
+}
+export { TestItemImpl, TestItemRootImpl };

package/dist/vscode/vs/workbench/api/common/extHostTestingPrivateApi.js

@@ -0,0 +1,15 @@
+import { InvalidTestItemError } from '../../contrib/testing/common/testItemCollection.js';
+const eventPrivateApis = ( new WeakMap());
+const createPrivateApiFor = (impl, controllerId) => {
+    const api = { controllerId };
+    eventPrivateApis.set(impl, api);
+    return api;
+};
+const getPrivateApiFor = (impl) => {
+    const api = eventPrivateApis.get(impl);
+    if (!api) {
+        throw new InvalidTestItemError(impl?.id || '<unknown>');
+    }
+    return api;
+};
+export { createPrivateApiFor, getPrivateApiFor };