@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/common/notebookDiffEditorInput.js

@@ -0,0 +1,101 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { isResourceDiffEditorInput } from '../../../common/editor.js';
+import { EditorModel } from '../../../common/editor/editorModel.js';
+import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
+import { NotebookEditorInput } from './notebookEditorInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+var NotebookDiffEditorInput_1;
+class NotebookDiffEditorModel extends EditorModel {
+    constructor(original, modified) {
+        super();
+        this.original = original;
+        this.modified = modified;
+    }
+}
+let NotebookDiffEditorInput = class NotebookDiffEditorInput extends DiffEditorInput {
+    static { NotebookDiffEditorInput_1 = this; }
+    static create(instantiationService, resource, name, description, originalResource, viewType) {
+        const original = NotebookEditorInput.getOrCreate(instantiationService, originalResource, undefined, viewType);
+        const modified = NotebookEditorInput.getOrCreate(instantiationService, resource, undefined, viewType);
+        return instantiationService.createInstance(NotebookDiffEditorInput_1, name, description, original, modified, viewType);
+    }
+    static { this.ID = 'workbench.input.diffNotebookInput'; }
+    get resource() {
+        return this.modified.resource;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    constructor(name, description, original, modified, viewType, editorService) {
+        super(name, description, original, modified, undefined, editorService);
+        this.original = original;
+        this.modified = modified;
+        this.viewType = viewType;
+        this._modifiedTextModel = null;
+        this._originalTextModel = null;
+        this._cachedModel = undefined;
+    }
+    get typeId() {
+        return NotebookDiffEditorInput_1.ID;
+    }
+    async resolve() {
+        const [originalEditorModel, modifiedEditorModel] = await Promise.all([
+            this.original.resolve(),
+            this.modified.resolve(),
+        ]);
+        this._cachedModel?.dispose();
+        if (!modifiedEditorModel) {
+            throw new Error(`Fail to resolve modified editor model for resource ${this.modified.resource} with notebookType ${this.viewType}`);
+        }
+        if (!originalEditorModel) {
+            throw new Error(`Fail to resolve original editor model for resource ${this.original.resource} with notebookType ${this.viewType}`);
+        }
+        this._originalTextModel = originalEditorModel;
+        this._modifiedTextModel = modifiedEditorModel;
+        this._cachedModel = ( new NotebookDiffEditorModel(this._originalTextModel, this._modifiedTextModel));
+        return this._cachedModel;
+    }
+    toUntyped() {
+        const original = { resource: this.original.resource };
+        const modified = { resource: this.resource };
+        return {
+            original,
+            modified,
+            primary: modified,
+            secondary: original,
+            options: {
+                override: this.viewType
+            }
+        };
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof NotebookDiffEditorInput_1) {
+            return this.modified.matches(otherInput.modified)
+                && this.original.matches(otherInput.original)
+                && this.viewType === otherInput.viewType;
+        }
+        if (isResourceDiffEditorInput(otherInput)) {
+            return this.modified.matches(otherInput.modified)
+                && this.original.matches(otherInput.original)
+                && this.editorId !== undefined
+                && (this.editorId === otherInput.options?.override || otherInput.options?.override === undefined);
+        }
+        return false;
+    }
+    dispose() {
+        super.dispose();
+        this._cachedModel?.dispose();
+        this._cachedModel = undefined;
+        this.original.dispose();
+        this.modified.dispose();
+        this._originalTextModel = null;
+        this._modifiedTextModel = null;
+    }
+};
+NotebookDiffEditorInput = NotebookDiffEditorInput_1 = ( __decorate([
+    ( __param(5, IEditorService))
+], NotebookDiffEditorInput));
+export { NotebookDiffEditorInput };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js

@@ -0,0 +1,201 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { URI } from '../../../../base/common/uri.js';
+import { CellUri, NotebookSetting, NotebookWorkingCopyTypeIdentifier } from './notebookCommon.js';
+import { SimpleNotebookEditorModel, NotebookFileWorkingCopyModelFactory } from './notebookEditorModel.js';
+import { ReferenceCollection, DisposableStore, dispose, combinedDisposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { INotebookService } from './notebookService.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { AsyncEmitter, Emitter } from '../../../../base/common/event.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { FileWorkingCopyManager } from '../../../services/workingCopy/common/fileWorkingCopyManager.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { NotebookProviderInfo } from './notebookProvider.js';
+import { assertIsDefined } from '../../../../base/common/types.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+let NotebookModelReferenceCollection = class NotebookModelReferenceCollection extends ReferenceCollection {
+    constructor(_instantiationService, _notebookService, _logService, _configurationService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._notebookService = _notebookService;
+        this._logService = _logService;
+        this._configurationService = _configurationService;
+        this._disposables = ( new DisposableStore());
+        this._workingCopyManagers = ( new Map());
+        this._modelListener = ( new Map());
+        this._onDidSaveNotebook = ( new Emitter());
+        this.onDidSaveNotebook = this._onDidSaveNotebook.event;
+        this._onDidChangeDirty = ( new Emitter());
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._dirtyStates = ( new ResourceMap());
+        this.modelsToDispose = ( new Set());
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._onDidSaveNotebook.dispose();
+        this._onDidChangeDirty.dispose();
+        dispose(( this._modelListener.values()));
+        dispose(( this._workingCopyManagers.values()));
+    }
+    isDirty(resource) {
+        return this._dirtyStates.get(resource) ?? false;
+    }
+    async createReferencedObject(key, viewType, hasAssociatedFilePath, limits) {
+        this.modelsToDispose.delete(key);
+        const uri = ( URI.parse(key));
+        const workingCopyTypeId = NotebookWorkingCopyTypeIdentifier.create(viewType);
+        let workingCopyManager = this._workingCopyManagers.get(workingCopyTypeId);
+        if (!workingCopyManager) {
+            const factory = ( new NotebookFileWorkingCopyModelFactory(viewType, this._notebookService, this._configurationService));
+            workingCopyManager = this._instantiationService.createInstance(FileWorkingCopyManager, workingCopyTypeId, factory, factory);
+            this._workingCopyManagers.set(workingCopyTypeId, workingCopyManager);
+        }
+        const scratchPad = viewType === 'interactive' && this._configurationService.getValue(NotebookSetting.InteractiveWindowPromptToSave) !== true;
+        const model = this._instantiationService.createInstance(SimpleNotebookEditorModel, uri, hasAssociatedFilePath, viewType, workingCopyManager, scratchPad);
+        const result = await model.load({ limits });
+        let onDirtyAutoReference;
+        this._modelListener.set(result, combinedDisposable(result.onDidSave(() => this._onDidSaveNotebook.fire(result.resource)), result.onDidChangeDirty(() => {
+            const isDirty = result.isDirty();
+            this._dirtyStates.set(result.resource, isDirty);
+            if (isDirty && !onDirtyAutoReference) {
+                onDirtyAutoReference = this.acquire(key, viewType);
+            }
+            else if (onDirtyAutoReference) {
+                onDirtyAutoReference.dispose();
+                onDirtyAutoReference = undefined;
+            }
+            this._onDidChangeDirty.fire(result);
+        }), toDisposable(() => onDirtyAutoReference?.dispose())));
+        return result;
+    }
+    destroyReferencedObject(key, object) {
+        this.modelsToDispose.add(key);
+        (async () => {
+            try {
+                const model = await object;
+                if (!( this.modelsToDispose.has(key))) {
+                    return;
+                }
+                if (model instanceof SimpleNotebookEditorModel) {
+                    await model.canDispose();
+                }
+                if (!( this.modelsToDispose.has(key))) {
+                    return;
+                }
+                this._modelListener.get(model)?.dispose();
+                this._modelListener.delete(model);
+                model.dispose();
+            }
+            catch (err) {
+                this._logService.error('FAILED to destory notebook', err);
+            }
+            finally {
+                this.modelsToDispose.delete(key);
+            }
+        })();
+    }
+};
+NotebookModelReferenceCollection = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, INotebookService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IConfigurationService))
+], NotebookModelReferenceCollection));
+let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
+    constructor(instantiationService, _notebookService, _extensionService, _uriIdentService) {
+        this._notebookService = _notebookService;
+        this._extensionService = _extensionService;
+        this._uriIdentService = _uriIdentService;
+        this._onWillFailWithConflict = ( new AsyncEmitter());
+        this.onWillFailWithConflict = this._onWillFailWithConflict.event;
+        this._data = instantiationService.createInstance(NotebookModelReferenceCollection);
+        this.onDidSaveNotebook = this._data.onDidSaveNotebook;
+        this.onDidChangeDirty = this._data.onDidChangeDirty;
+    }
+    dispose() {
+        this._data.dispose();
+    }
+    isDirty(resource) {
+        return this._data.isDirty(resource);
+    }
+    async resolve(arg0, viewType, limits) {
+        let resource;
+        let hasAssociatedFilePath = false;
+        if (URI.isUri(arg0)) {
+            resource = arg0;
+        }
+        else {
+            if (!arg0.untitledResource) {
+                const info = this._notebookService.getContributedNotebookType(assertIsDefined(viewType));
+                if (!info) {
+                    throw new Error('UNKNOWN view type: ' + viewType);
+                }
+                const suffix = NotebookProviderInfo.possibleFileEnding(info.selectors) ?? '';
+                for (let counter = 1;; counter++) {
+                    const candidate = ( URI.from(
+                        { scheme: Schemas.untitled, path: `Untitled-${counter}${suffix}`, query: viewType }
+                    ));
+                    if (!this._notebookService.getNotebookTextModel(candidate)) {
+                        resource = candidate;
+                        break;
+                    }
+                }
+            }
+            else if (arg0.untitledResource.scheme === Schemas.untitled) {
+                resource = arg0.untitledResource;
+            }
+            else {
+                resource = arg0.untitledResource.with({ scheme: Schemas.untitled });
+                hasAssociatedFilePath = true;
+            }
+        }
+        if (resource.scheme === CellUri.scheme) {
+            throw new Error(`CANNOT open a cell-uri as notebook. Tried with ${resource.toString()}`);
+        }
+        resource = this._uriIdentService.asCanonicalUri(resource);
+        const existingViewType = this._notebookService.getNotebookTextModel(resource)?.viewType;
+        if (!viewType) {
+            if (existingViewType) {
+                viewType = existingViewType;
+            }
+            else {
+                await this._extensionService.whenInstalledExtensionsRegistered();
+                const providers = this._notebookService.getContributedNotebookTypes(resource);
+                const exclusiveProvider = providers.find(provider => provider.exclusive);
+                viewType = exclusiveProvider?.id || providers[0]?.id;
+            }
+        }
+        if (!viewType) {
+            throw new Error(`Missing viewType for '${resource}'`);
+        }
+        if (existingViewType && existingViewType !== viewType) {
+            await this._onWillFailWithConflict.fireAsync({ resource, viewType }, CancellationToken.None);
+            const existingViewType2 = this._notebookService.getNotebookTextModel(resource)?.viewType;
+            if (existingViewType2 && existingViewType2 !== viewType) {
+                throw new Error(`A notebook with view type '${existingViewType2}' already exists for '${resource}', CANNOT create another notebook with view type ${viewType}`);
+            }
+        }
+        const reference = this._data.acquire(( resource.toString()), viewType, hasAssociatedFilePath, limits);
+        try {
+            const model = await reference.object;
+            return {
+                object: model,
+                dispose() { reference.dispose(); }
+            };
+        }
+        catch (err) {
+            reference.dispose();
+            throw err;
+        }
+    }
+};
+NotebookModelResolverServiceImpl = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, INotebookService)),
+    ( __param(2, IExtensionService)),
+    ( __param(3, IUriIdentityService))
+], NotebookModelResolverServiceImpl));
+export { NotebookModelResolverServiceImpl };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookOutputRenderer.js

@@ -0,0 +1,78 @@
+import { parse } from '../../../../base/common/glob.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { joinPath } from '../../../../base/common/resources.js';
+class DependencyList {
+    constructor(value) {
+        this.value = ( new Set(value));
+        this.defined = this.value.size > 0;
+    }
+    matches(available) {
+        return ( available.some(v => ( this.value.has(v))));
+    }
+}
+class NotebookOutputRendererInfo {
+    constructor(descriptor) {
+        this.id = descriptor.id;
+        this.extensionId = descriptor.extension.identifier;
+        this.extensionLocation = descriptor.extension.extensionLocation;
+        this.isBuiltin = descriptor.extension.isBuiltin;
+        if (typeof descriptor.entrypoint === 'string') {
+            this.entrypoint = {
+                extends: undefined,
+                path: joinPath(this.extensionLocation, descriptor.entrypoint)
+            };
+        }
+        else {
+            this.entrypoint = {
+                extends: descriptor.entrypoint.extends,
+                path: joinPath(this.extensionLocation, descriptor.entrypoint.path)
+            };
+        }
+        this.displayName = descriptor.displayName;
+        this.mimeTypes = descriptor.mimeTypes;
+        this.mimeTypeGlobs = ( this.mimeTypes.map(pattern => parse(pattern)));
+        this.hardDependencies = ( new DependencyList(descriptor.dependencies ?? Iterable.empty()));
+        this.optionalDependencies = ( new DependencyList(descriptor.optionalDependencies ?? Iterable.empty()));
+        this.messaging = descriptor.requiresMessaging ?? "never" ;
+    }
+    matchesWithoutKernel(mimeType) {
+        if (!this.matchesMimeTypeOnly(mimeType)) {
+            return 3 ;
+        }
+        if (this.hardDependencies.defined) {
+            return 0 ;
+        }
+        if (this.optionalDependencies.defined) {
+            return 1 ;
+        }
+        return 2 ;
+    }
+    matches(mimeType, kernelProvides) {
+        if (!this.matchesMimeTypeOnly(mimeType)) {
+            return 3 ;
+        }
+        if (this.hardDependencies.defined) {
+            return this.hardDependencies.matches(kernelProvides)
+                ? 0
+                : 3 ;
+        }
+        return this.optionalDependencies.matches(kernelProvides)
+            ? 1
+            : 2 ;
+    }
+    matchesMimeTypeOnly(mimeType) {
+        if (this.entrypoint.extends) {
+            return false;
+        }
+        return ( this.mimeTypeGlobs.some(pattern => pattern(mimeType))) || ( this.mimeTypes.some(pattern => pattern === mimeType));
+    }
+}
+class NotebookStaticPreloadInfo {
+    constructor(descriptor) {
+        this.type = descriptor.type;
+        this.entrypoint = joinPath(descriptor.extension.extensionLocation, descriptor.entrypoint);
+        this.extensionLocation = descriptor.extension.extensionLocation;
+        this.localResourceRoots = ( descriptor.localResourceRoots.map(root => joinPath(descriptor.extension.extensionLocation, root)));
+    }
+}
+export { NotebookOutputRendererInfo, NotebookStaticPreloadInfo };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookProvider.js

@@ -0,0 +1,96 @@
+import { match, isRelativePattern } from '../../../../base/common/glob.js';
+import { basename } from '../../../../base/common/path.js';
+import { isDocumentExcludePattern } from './notebookCommon.js';
+class NotebookProviderInfo {
+    get selectors() {
+        return this._selectors;
+    }
+    get options() {
+        return this._options;
+    }
+    constructor(descriptor) {
+        this.extension = descriptor.extension;
+        this.id = descriptor.id;
+        this.displayName = descriptor.displayName;
+        this._selectors = descriptor.selectors?.map(selector => ({
+            include: selector.filenamePattern,
+            exclude: selector.excludeFileNamePattern || ''
+        })) || [];
+        this.priority = descriptor.priority;
+        this.providerDisplayName = descriptor.providerDisplayName;
+        this.exclusive = descriptor.exclusive;
+        this._options = {
+            transientCellMetadata: {},
+            transientDocumentMetadata: {},
+            transientOutputs: false,
+            cellContentMetadata: {}
+        };
+    }
+    update(args) {
+        if (args.selectors) {
+            this._selectors = args.selectors;
+        }
+        if (args.options) {
+            this._options = args.options;
+        }
+    }
+    matches(resource) {
+        return this.selectors?.some(selector => NotebookProviderInfo.selectorMatches(selector, resource));
+    }
+    static selectorMatches(selector, resource) {
+        if (typeof selector === 'string') {
+            if (match(selector.toLowerCase(), basename(resource.fsPath).toLowerCase())) {
+                return true;
+            }
+        }
+        if (isRelativePattern(selector)) {
+            if (match(selector, basename(resource.fsPath).toLowerCase())) {
+                return true;
+            }
+        }
+        if (!isDocumentExcludePattern(selector)) {
+            return false;
+        }
+        const filenamePattern = selector.include;
+        const excludeFilenamePattern = selector.exclude;
+        if (match(filenamePattern, basename(resource.fsPath).toLowerCase())) {
+            if (excludeFilenamePattern) {
+                if (match(excludeFilenamePattern, basename(resource.fsPath).toLowerCase())) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    static possibleFileEnding(selectors) {
+        for (const selector of selectors) {
+            const ending = NotebookProviderInfo._possibleFileEnding(selector);
+            if (ending) {
+                return ending;
+            }
+        }
+        return undefined;
+    }
+    static _possibleFileEnding(selector) {
+        const pattern = /^.*(\.[a-zA-Z0-9_-]+)$/;
+        let candidate;
+        if (typeof selector === 'string') {
+            candidate = selector;
+        }
+        else if (isRelativePattern(selector)) {
+            candidate = selector.pattern;
+        }
+        else if (selector.include) {
+            return NotebookProviderInfo._possibleFileEnding(selector.include);
+        }
+        if (candidate) {
+            const match = pattern.exec(candidate);
+            if (match) {
+                return match[1];
+            }
+        }
+        return undefined;
+    }
+}
+export { NotebookProviderInfo };