@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

package/vscode/src/vs/workbench/services/commands/common/commandService.js

@@ -1,77 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IExtensionService } from '../../extensions/common/extensions.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
-let CommandService = class CommandService extends Disposable {
-    constructor(_instantiationService, _extensionService, _logService) {
-        super();
-        this._instantiationService = _instantiationService;
-        this._extensionService = _extensionService;
-        this._logService = _logService;
-        this._extensionHostIsReady = false;
-        this._onWillExecuteCommand = this._register(( new Emitter()));
-        this.onWillExecuteCommand = this._onWillExecuteCommand.event;
-        this._onDidExecuteCommand = ( new Emitter());
-        this.onDidExecuteCommand = this._onDidExecuteCommand.event;
-        this._extensionService.whenInstalledExtensionsRegistered().then(value => this._extensionHostIsReady = value);
-        this._starActivation = null;
-    }
-    _activateStar() {
-        if (!this._starActivation) {
-            this._starActivation = Promise.race([
-                this._extensionService.activateByEvent(`*`),
-                timeout(30000)
-            ]);
-        }
-        return this._starActivation;
-    }
-    async executeCommand(id, ...args) {
-        this._logService.trace('CommandService#executeCommand', id);
-        const activationEvent = `onCommand:${id}`;
-        const commandIsRegistered = !!CommandsRegistry.getCommand(id);
-        if (commandIsRegistered) {
-            if (this._extensionService.activationEventIsDone(activationEvent)) {
-                return this._tryExecuteCommand(id, args);
-            }
-            if (!this._extensionHostIsReady) {
-                this._extensionService.activateByEvent(activationEvent);
-                return this._tryExecuteCommand(id, args);
-            }
-            await this._extensionService.activateByEvent(activationEvent);
-            return this._tryExecuteCommand(id, args);
-        }
-        await Promise.all([
-            this._extensionService.activateByEvent(activationEvent),
-            Promise.race([
-                this._activateStar(),
-                Event.toPromise(Event.filter(CommandsRegistry.onDidRegisterCommand, e => e === id))
-            ]),
-        ]);
-        return this._tryExecuteCommand(id, args);
-    }
-    _tryExecuteCommand(id, args) {
-        const command = CommandsRegistry.getCommand(id);
-        if (!command) {
-            return Promise.reject(( new Error(`command '${id}' not found`)));
-        }
-        try {
-            this._onWillExecuteCommand.fire({ commandId: id, args });
-            const result = this._instantiationService.invokeFunction(command.handler, ...args);
-            this._onDidExecuteCommand.fire({ commandId: id, args });
-            return Promise.resolve(result);
-        }
-        catch (err) {
-            return Promise.reject(err);
-        }
-    }
-};
-CommandService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IExtensionService)),
-    ( __param(2, ILogService))
-], CommandService));
-export { CommandService };

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.js

@@ -1,141 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
-import { IWorkbenchExtensionEnablementService } from '../../extensionManagement/common/extensionManagement.js';
-import { WebWorkerExtensionHost } from './webWorkerExtensionHost.js';
-import { checkEnabledAndProposedAPI } from '../common/abstractExtensionService.js';
-import { extensionRunningPreferenceToString, extensionHostKindToString } from '../common/extensionHostKind.js';
-import { filterExtensionDescriptions } from '../common/extensionRunningLocationTracker.js';
-import { ExtensionHostExtensions } from '../common/extensions.js';
-import { RemoteExtensionHost } from '../common/remoteExtensionHost.js';
-import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
-var BrowserExtensionHostKindPicker_1;
-let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
-    constructor(_extensionsProposedApi, _scanWebExtensions, _getExtensionRegistrySnapshotWhenReady, _instantiationService, _remoteAgentService, _remoteAuthorityResolverService, _extensionEnablementService, _logService) {
-        this._extensionsProposedApi = _extensionsProposedApi;
-        this._scanWebExtensions = _scanWebExtensions;
-        this._getExtensionRegistrySnapshotWhenReady = _getExtensionRegistrySnapshotWhenReady;
-        this._instantiationService = _instantiationService;
-        this._remoteAgentService = _remoteAgentService;
-        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
-        this._extensionEnablementService = _extensionEnablementService;
-        this._logService = _logService;
-    }
-    createExtensionHost(runningLocations, runningLocation, isInitialStart) {
-        switch (runningLocation.kind) {
-            case 1 : {
-                return null;
-            }
-            case 2 : {
-                const startup = ((isInitialStart ? 2  : 1) );
-                return this._instantiationService.createInstance(WebWorkerExtensionHost, runningLocation, startup, this._createLocalExtensionHostDataProvider(runningLocations, runningLocation, isInitialStart));
-            }
-            case 3 : {
-                const remoteAgentConnection = this._remoteAgentService.getConnection();
-                if (remoteAgentConnection) {
-                    return this._instantiationService.createInstance(RemoteExtensionHost, runningLocation, this._createRemoteExtensionHostDataProvider(runningLocations, remoteAgentConnection.remoteAuthority));
-                }
-                return null;
-            }
-        }
-    }
-    _createLocalExtensionHostDataProvider(runningLocations, desiredRunningLocation, isInitialStart) {
-        return {
-            getInitData: async () => {
-                if (isInitialStart) {
-                    const localExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, await this._scanWebExtensions(),  true);
-                    const runningLocation = runningLocations.computeRunningLocation(localExtensions, [], false);
-                    const myExtensions = filterExtensionDescriptions(localExtensions, runningLocation, extRunningLocation => desiredRunningLocation.equals(extRunningLocation));
-                    const extensions = ( new ExtensionHostExtensions(0, localExtensions, ( myExtensions.map(extension => extension.identifier))));
-                    return { extensions };
-                }
-                else {
-                    const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
-                    const myExtensions = runningLocations.filterByRunningLocation(snapshot.extensions, desiredRunningLocation);
-                    const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
-                    return { extensions };
-                }
-            }
-        };
-    }
-    _createRemoteExtensionHostDataProvider(runningLocations, remoteAuthority) {
-        return {
-            remoteAuthority: remoteAuthority,
-            getInitData: async () => {
-                const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
-                const remoteEnv = await this._remoteAgentService.getEnvironment();
-                if (!remoteEnv) {
-                    throw new Error('Cannot provide init data for remote extension host!');
-                }
-                const myExtensions = runningLocations.filterByExtensionHostKind(snapshot.extensions, 3 );
-                const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
-                return {
-                    connectionData: this._remoteAuthorityResolverService.getConnectionData(remoteAuthority),
-                    pid: remoteEnv.pid,
-                    appRoot: remoteEnv.appRoot,
-                    extensionHostLogsPath: remoteEnv.extensionHostLogsPath,
-                    globalStorageHome: remoteEnv.globalStorageHome,
-                    workspaceStorageHome: remoteEnv.workspaceStorageHome,
-                    extensions,
-                };
-            }
-        };
-    }
-};
-BrowserExtensionHostFactory = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IRemoteAgentService)),
-    ( __param(5, IRemoteAuthorityResolverService)),
-    ( __param(6, IWorkbenchExtensionEnablementService)),
-    ( __param(7, ILogService))
-], BrowserExtensionHostFactory));
-let BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = class BrowserExtensionHostKindPicker {
-    constructor(_logService) {
-        this._logService = _logService;
-    }
-    pickExtensionHostKind(extensionId, extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
-        const result = BrowserExtensionHostKindPicker_1.pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference);
-        this._logService.trace(`pickRunningLocation for ${extensionId.value}, extension kinds: [${extensionKinds.join(', ')}], isInstalledLocally: ${isInstalledLocally}, isInstalledRemotely: ${isInstalledRemotely}, preference: ${extensionRunningPreferenceToString(preference)} => ${extensionHostKindToString(result)}`);
-        return result;
-    }
-    static pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
-        const result = [];
-        let canRunRemotely = false;
-        for (const extensionKind of extensionKinds) {
-            if (extensionKind === 'ui' && isInstalledRemotely) {
-                if (preference === 2 ) {
-                    return 3 ;
-                }
-                else {
-                    canRunRemotely = true;
-                }
-            }
-            if (extensionKind === 'workspace' && isInstalledRemotely) {
-                if (preference === 0  || preference === 2 ) {
-                    return 3 ;
-                }
-                else {
-                    result.push(3 );
-                }
-            }
-            if (extensionKind === 'web' && (isInstalledLocally || isInstalledRemotely)) {
-                if (preference === 0  || preference === 1 ) {
-                    return 2 ;
-                }
-                else {
-                    result.push(2 );
-                }
-            }
-        }
-        if (canRunRemotely) {
-            result.push(3 );
-        }
-        return (result.length > 0 ? result[0] : null);
-    }
-};
-BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = ( __decorate([
-    ( __param(0, ILogService))
-], BrowserExtensionHostKindPicker));
-export { BrowserExtensionHostFactory, BrowserExtensionHostKindPicker };

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.js

@@ -1,271 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { parentOriginHash } from 'monaco-editor/esm/vs/base/browser/iframe.js';
-import { Barrier } from 'monaco-editor/esm/vs/base/common/async.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { canceled, onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { COI, FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
-import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
-import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
-import { ILogService, ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { isLoggingOnly } from '../../../../platform/telemetry/common/telemetryUtils.js';
-import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.js';
-import { isMessageOfType, createMessageOfType, UIKind } from '../common/extensionHostProtocol.js';
-let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
-    constructor(runningLocation, startup, _initDataProvider, _telemetryService, _contextService, _labelService, _logService, _loggerService, _environmentService, _userDataProfilesService, _productService, _layoutService, _storageService) {
-        super();
-        this.runningLocation = runningLocation;
-        this.startup = startup;
-        this._initDataProvider = _initDataProvider;
-        this._telemetryService = _telemetryService;
-        this._contextService = _contextService;
-        this._labelService = _labelService;
-        this._logService = _logService;
-        this._loggerService = _loggerService;
-        this._environmentService = _environmentService;
-        this._userDataProfilesService = _userDataProfilesService;
-        this._productService = _productService;
-        this._layoutService = _layoutService;
-        this._storageService = _storageService;
-        this.remoteAuthority = null;
-        this.extensions = null;
-        this._onDidExit = this._register(( new Emitter()));
-        this.onExit = this._onDidExit.event;
-        this._isTerminating = false;
-        this._protocolPromise = null;
-        this._protocol = null;
-        this._extensionHostLogsLocation = joinPath(this._environmentService.extHostLogsPath, 'webWorker');
-    }
-    async _getWebWorkerExtensionHostIframeSrc() {
-        const suffixSearchParams = ( new URLSearchParams());
-        if (this._environmentService.debugExtensionHost && this._environmentService.debugRenderer) {
-            suffixSearchParams.set('debugged', '1');
-        }
-        COI.addSearchParam(suffixSearchParams, true, true);
-        const suffix = `?${( suffixSearchParams.toString())}`;
-        const iframeModulePath = 'vs/workbench/services/extensions/worker/webWorkerExtensionHostIframe.html';
-        if (platform.isWeb) {
-            const webEndpointUrlTemplate = this._productService.webEndpointUrlTemplate;
-            const commit = this._productService.commit;
-            const quality = this._productService.quality;
-            if (webEndpointUrlTemplate && commit && quality) {
-                const key = 'webWorkerExtensionHostIframeStableOriginUUID';
-                let stableOriginUUID = this._storageService.get(key, 1 );
-                if (typeof stableOriginUUID === 'undefined') {
-                    stableOriginUUID = generateUuid();
-                    this._storageService.store(key, stableOriginUUID, 1 , 1 );
-                }
-                const hash = await parentOriginHash(window.origin, stableOriginUUID);
-                const baseUrl = (webEndpointUrlTemplate
-                    .replace('{{uuid}}', `v--${hash}`)
-                    .replace('{{commit}}', commit)
-                    .replace('{{quality}}', quality));
-                const res = ( new URL(`${baseUrl}/out/${iframeModulePath}${suffix}`));
-                res.searchParams.set('parentOrigin', window.origin);
-                res.searchParams.set('salt', stableOriginUUID);
-                return ( res.toString());
-            }
-        }
-        const relativeExtensionHostIframeSrc = ( FileAccess.asBrowserUri(iframeModulePath));
-        return `${( relativeExtensionHostIframeSrc.toString(true))}${suffix}`;
-    }
-    async start() {
-        if (!this._protocolPromise) {
-            this._protocolPromise = this._startInsideIframe();
-            this._protocolPromise.then(protocol => this._protocol = protocol);
-        }
-        return this._protocolPromise;
-    }
-    async _startInsideIframe() {
-        const webWorkerExtensionHostIframeSrc = await this._getWebWorkerExtensionHostIframeSrc();
-        const emitter = this._register(( new Emitter()));
-        const iframe = document.createElement('iframe');
-        iframe.setAttribute('class', 'web-worker-ext-host-iframe');
-        iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
-        iframe.setAttribute('allow', 'usb; serial; hid; cross-origin-isolated;');
-        iframe.setAttribute('aria-hidden', 'true');
-        iframe.style.display = 'none';
-        const vscodeWebWorkerExtHostId = generateUuid();
-        iframe.setAttribute('src', `${webWorkerExtensionHostIframeSrc}&vscodeWebWorkerExtHostId=${vscodeWebWorkerExtHostId}`);
-        const barrier = ( new Barrier());
-        let port;
-        let barrierError = null;
-        let barrierHasError = false;
-        let startTimeout = null;
-        const rejectBarrier = (exitCode, error) => {
-            barrierError = error;
-            barrierHasError = true;
-            onUnexpectedError(barrierError);
-            clearTimeout(startTimeout);
-            this._onDidExit.fire([81 , barrierError.message]);
-            barrier.open();
-        };
-        const resolveBarrier = (messagePort) => {
-            port = messagePort;
-            clearTimeout(startTimeout);
-            barrier.open();
-        };
-        startTimeout = setTimeout(() => {
-            console.warn(`The Web Worker Extension Host did not start in 60s, that might be a problem.`);
-        }, 60000);
-        this._register(dom.addDisposableListener(window, 'message', (event) => {
-            if (event.source !== iframe.contentWindow) {
-                return;
-            }
-            if (event.data.vscodeWebWorkerExtHostId !== vscodeWebWorkerExtHostId) {
-                return;
-            }
-            if (event.data.error) {
-                const { name, message, stack } = event.data.error;
-                const err = ( new Error());
-                err.message = message;
-                err.name = name;
-                err.stack = stack;
-                return rejectBarrier(81 , err);
-            }
-            const { data } = event.data;
-            if (barrier.isOpen() || !(data instanceof MessagePort)) {
-                console.warn('UNEXPECTED message', event);
-                const err = ( new Error('UNEXPECTED message'));
-                return rejectBarrier(81 , err);
-            }
-            resolveBarrier(data);
-        }));
-        this._layoutService.container.appendChild(iframe);
-        this._register(toDisposable(() => iframe.remove()));
-        await barrier.wait();
-        if (barrierHasError) {
-            throw barrierError;
-        }
-        const messagePorts = this._environmentService.options?.messagePorts ?? ( new Map());
-        iframe.contentWindow.postMessage({ type: 'vscode.init', data: messagePorts }, '*', [...( messagePorts.values())]);
-        port.onmessage = (event) => {
-            const { data } = event;
-            if (!(data instanceof ArrayBuffer)) {
-                console.warn('UNKNOWN data received', data);
-                this._onDidExit.fire([77, 'UNKNOWN data received']);
-                return;
-            }
-            emitter.fire(VSBuffer.wrap(( new Uint8Array(data, 0, data.byteLength))));
-        };
-        const protocol = {
-            onMessage: emitter.event,
-            send: vsbuf => {
-                const data = vsbuf.buffer.buffer.slice(vsbuf.buffer.byteOffset, vsbuf.buffer.byteOffset + vsbuf.buffer.byteLength);
-                port.postMessage(data, [data]);
-            }
-        };
-        return this._performHandshake(protocol);
-    }
-    async _performHandshake(protocol) {
-        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, 1 )));
-        if (this._isTerminating) {
-            throw canceled();
-        }
-        protocol.send(VSBuffer.fromString(JSON.stringify(await this._createExtHostInitData())));
-        if (this._isTerminating) {
-            throw canceled();
-        }
-        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, 0 )));
-        if (this._isTerminating) {
-            throw canceled();
-        }
-        return protocol;
-    }
-    dispose() {
-        if (this._isTerminating) {
-            return;
-        }
-        this._isTerminating = true;
-        this._protocol?.send(createMessageOfType(2 ));
-        super.dispose();
-    }
-    getInspectPort() {
-        return undefined;
-    }
-    enableInspectPort() {
-        return Promise.resolve(false);
-    }
-    async _createExtHostInitData() {
-        const initData = await this._initDataProvider.getInitData();
-        this.extensions = initData.extensions;
-        const workspace = this._contextService.getWorkspace();
-        const nlsBaseUrl = this._productService.extensionsGallery?.nlsBaseUrl;
-        let nlsUrlWithDetails = undefined;
-        if (nlsBaseUrl && this._productService.commit && !platform.Language.isDefaultVariant()) {
-            nlsUrlWithDetails = URI.joinPath(( URI.parse(nlsBaseUrl)), this._productService.commit, this._productService.version, platform.Language.value());
-        }
-        return {
-            commit: this._productService.commit,
-            version: this._productService.version,
-            quality: this._productService.quality,
-            parentPid: 0,
-            environment: {
-                isExtensionDevelopmentDebug: this._environmentService.debugRenderer,
-                appName: this._productService.nameLong,
-                appHost: this._productService.embedderIdentifier ?? (platform.isWeb ? 'web' : 'desktop'),
-                appUriScheme: this._productService.urlProtocol,
-                appLanguage: platform.language,
-                extensionTelemetryLogResource: this._environmentService.extHostTelemetryLogFile,
-                isExtensionTelemetryLoggingOnly: isLoggingOnly(this._productService, this._environmentService),
-                extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
-                extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
-                globalStorageHome: this._userDataProfilesService.defaultProfile.globalStorageHome,
-                workspaceStorageHome: this._environmentService.workspaceStorageHome,
-                extensionLogLevel: this._environmentService.extensionLogLevel
-            },
-            workspace: this._contextService.getWorkbenchState() === 1  ? undefined : {
-                configuration: workspace.configuration || undefined,
-                id: workspace.id,
-                name: this._labelService.getWorkspaceLabel(workspace),
-                transient: workspace.transient
-            },
-            consoleForward: {
-                includeStack: false,
-                logNative: this._environmentService.debugRenderer
-            },
-            extensions: this.extensions.toSnapshot(),
-            nlsBaseUrl: nlsUrlWithDetails,
-            telemetryInfo: {
-                sessionId: this._telemetryService.sessionId,
-                machineId: this._telemetryService.machineId,
-                firstSessionDate: this._telemetryService.firstSessionDate,
-                msftInternal: this._telemetryService.msftInternal
-            },
-            logLevel: this._logService.getLevel(),
-            loggers: [...this._loggerService.getRegisteredLoggers()],
-            logsLocation: this._extensionHostLogsLocation,
-            autoStart: ((this.startup === 1) ),
-            remote: {
-                authority: this._environmentService.remoteAuthority,
-                connectionData: null,
-                isRemote: false
-            },
-            uiKind: platform.isWeb ? UIKind.Web : UIKind.Desktop
-        };
-    }
-};
-WebWorkerExtensionHost = ( __decorate([
-    ( __param(3, ITelemetryService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, ILogService)),
-    ( __param(7, ILoggerService)),
-    ( __param(8, IBrowserWorkbenchEnvironmentService)),
-    ( __param(9, IUserDataProfilesService)),
-    ( __param(10, IProductService)),
-    ( __param(11, ILayoutService)),
-    ( __param(12, IStorageService))
-], WebWorkerExtensionHost));
-export { WebWorkerExtensionHost };

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerFileSystemProvider.js

@@ -1,50 +0,0 @@
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { NotSupportedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-class FetchFileSystemProvider {
-    constructor() {
-        this.capabilities = 2048  + 2  + 1024 ;
-        this.onDidChangeCapabilities = Event.None;
-        this.onDidChangeFile = Event.None;
-    }
-    async readFile(resource) {
-        try {
-            const res = await fetch(( resource.toString(true)));
-            if (res.status === 200) {
-                return ( new Uint8Array(await res.arrayBuffer()));
-            }
-            throw createFileSystemProviderError(res.statusText, FileSystemProviderErrorCode.Unknown);
-        }
-        catch (err) {
-            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
-        }
-    }
-    async stat(_resource) {
-        return {
-            type: FileType.File,
-            size: 0,
-            mtime: 0,
-            ctime: 0
-        };
-    }
-    watch() {
-        return Disposable.None;
-    }
-    writeFile(_resource, _content, _opts) {
-        throw new NotSupportedError();
-    }
-    readdir(_resource) {
-        throw new NotSupportedError();
-    }
-    mkdir(_resource) {
-        throw new NotSupportedError();
-    }
-    delete(_resource, _opts) {
-        throw new NotSupportedError();
-    }
-    rename(_from, _to, _opts) {
-        throw new NotSupportedError();
-    }
-}
-export { FetchFileSystemProvider };