@theia/core/lib/common/resource.js

"use strict";
// *****************************************************************************
// Copyright (C) 2017 TypeFox and others.
//
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License v. 2.0 which is available at
// http://www.eclipse.org/legal/epl-2.0.
//
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License v. 2.0 are satisfied: GNU General Public License, version 2
// with the GNU Classpath Exception which is available at
// https://www.gnu.org/software/classpath/license.html.
//
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
// *****************************************************************************
Object.defineProperty(exports, "__esModule", { value: true });
exports.createUntitledURI = exports.UntitledResource = exports.UntitledResourceResolver = exports.UNTITLED_SCHEME = exports.InMemoryTextResourceResolver = exports.InMemoryTextResource = exports.MEMORY_TEXT = exports.InMemoryResources = exports.ReferenceMutableResource = exports.MutableResource = exports.DefaultResourceProvider = exports.ResourceProvider = exports.ResourceResolver = exports.ResourceError = exports.Resource = void 0;
const tslib_1 = require("tslib");
const inversify_1 = require("inversify");
const uri_1 = require("../common/uri");
const contribution_provider_1 = require("./contribution-provider");
const event_1 = require("./event");
const application_error_1 = require("./application-error");
const stream_1 = require("./stream");
const reference_1 = require("./reference");
var Resource;
(function (Resource) {
    async function save(resource, context, token) {
        if (!resource.saveContents) {
            return;
        }
        if (await trySaveContentChanges(resource, context)) {
            return;
        }
        if (token && token.isCancellationRequested) {
            return;
        }
        if (typeof context.content !== 'string' && resource.saveStream) {
            await resource.saveStream(context.content, context.options);
        }
        else {
            const content = typeof context.content === 'string' ? context.content : stream_1.Readable.toString(context.content);
            await resource.saveContents(content, context.options);
        }
    }
    Resource.save = save;
    async function trySaveContentChanges(resource, context) {
        if (!context.changes || !resource.saveContentChanges || shouldSaveContent(resource, context)) {
            return false;
        }
        try {
            await resource.saveContentChanges(context.changes, context.options);
            return true;
        }
        catch (e) {
            if (!ResourceError.NotFound.is(e) && !ResourceError.OutOfSync.is(e)) {
                console.error(`Failed to apply incremental changes to '${resource.uri.toString()}':`, e);
            }
            return false;
        }
    }
    Resource.trySaveContentChanges = trySaveContentChanges;
    function shouldSaveContent(resource, { contentLength, changes }) {
        if (!changes || (resource.saveStream && contentLength > 32 * 1024 * 1024)) {
            return true;
        }
        let contentChangesLength = 0;
        for (const change of changes) {
            contentChangesLength += JSON.stringify(change).length;
            if (contentChangesLength > contentLength) {
                return true;
            }
        }
        return contentChangesLength > contentLength;
    }
    Resource.shouldSaveContent = shouldSaveContent;
})(Resource = exports.Resource || (exports.Resource = {}));
var ResourceError;
(function (ResourceError) {
    ResourceError.NotFound = application_error_1.ApplicationError.declare(-40000, (raw) => raw);
    ResourceError.OutOfSync = application_error_1.ApplicationError.declare(-40001, (raw) => raw);
})(ResourceError = exports.ResourceError || (exports.ResourceError = {}));
exports.ResourceResolver = Symbol('ResourceResolver');
exports.ResourceProvider = Symbol('ResourceProvider');
let DefaultResourceProvider = class DefaultResourceProvider {
    constructor(resolversProvider) {
        this.resolversProvider = resolversProvider;
    }
    /**
     * Reject if a resource cannot be provided.
     */
    async get(uri) {
        const resolvers = this.resolversProvider.getContributions();
        for (const resolver of resolvers) {
            try {
                return await resolver.resolve(uri);
            }
            catch (err) {
                // no-op
            }
        }
        return Promise.reject(new Error(`A resource provider for '${uri.toString()}' is not registered.`));
    }
};
DefaultResourceProvider = (0, tslib_1.__decorate)([
    (0, inversify_1.injectable)(),
    (0, tslib_1.__param)(0, (0, inversify_1.inject)(contribution_provider_1.ContributionProvider)),
    (0, tslib_1.__param)(0, (0, inversify_1.named)(exports.ResourceResolver)),
    (0, tslib_1.__metadata)("design:paramtypes", [Object])
], DefaultResourceProvider);
exports.DefaultResourceProvider = DefaultResourceProvider;
class MutableResource {
    constructor(uri) {
        this.uri = uri;
        this.contents = '';
        this.onDidChangeContentsEmitter = new event_1.Emitter();
        this.onDidChangeContents = this.onDidChangeContentsEmitter.event;
    }
    dispose() { }
    async readContents() {
        return this.contents;
    }
    async saveContents(contents) {
        this.contents = contents;
        this.fireDidChangeContents();
    }
    fireDidChangeContents() {
        this.onDidChangeContentsEmitter.fire(undefined);
    }
}
exports.MutableResource = MutableResource;
class ReferenceMutableResource {
    constructor(reference) {
        this.reference = reference;
    }
    get uri() {
        return this.reference.object.uri;
    }
    get onDidChangeContents() {
        return this.reference.object.onDidChangeContents;
    }
    dispose() {
        this.reference.dispose();
    }
    readContents() {
        return this.reference.object.readContents();
    }
    saveContents(contents) {
        return this.reference.object.saveContents(contents);
    }
}
exports.ReferenceMutableResource = ReferenceMutableResource;
let InMemoryResources = class InMemoryResources {
    constructor() {
        this.resources = new reference_1.SyncReferenceCollection(uri => new MutableResource(new uri_1.default(uri)));
    }
    add(uri, contents) {
        const resourceUri = uri.toString();
        if (this.resources.has(resourceUri)) {
            throw new Error(`Cannot add already existing in-memory resource '${resourceUri}'`);
        }
        const resource = this.acquire(resourceUri);
        resource.saveContents(contents);
        return resource;
    }
    update(uri, contents) {
        const resourceUri = uri.toString();
        const resource = this.resources.get(resourceUri);
        if (!resource) {
            throw new Error(`Cannot update non-existed in-memory resource '${resourceUri}'`);
        }
        resource.saveContents(contents);
        return resource;
    }
    resolve(uri) {
        const uriString = uri.toString();
        if (!this.resources.has(uriString)) {
            throw new Error(`In memory '${uriString}' resource does not exist.`);
        }
        return this.acquire(uriString);
    }
    acquire(uri) {
        const reference = this.resources.acquire(uri);
        return new ReferenceMutableResource(reference);
    }
};
InMemoryResources = (0, tslib_1.__decorate)([
    (0, inversify_1.injectable)()
], InMemoryResources);
exports.InMemoryResources = InMemoryResources;
exports.MEMORY_TEXT = 'mem-txt';
/**
 * Resource implementation for 'mem-txt' URI scheme where content is saved in URI query.
 */
class InMemoryTextResource {
    constructor(uri) {
        this.uri = uri;
    }
    async readContents(options) {
        return this.uri.query;
    }
    dispose() { }
}
exports.InMemoryTextResource = InMemoryTextResource;
/**
 * ResourceResolver implementation for 'mem-txt' URI scheme.
 */
let InMemoryTextResourceResolver = class InMemoryTextResourceResolver {
    resolve(uri) {
        if (uri.scheme !== exports.MEMORY_TEXT) {
            throw new Error(`Expected a URI with ${exports.MEMORY_TEXT} scheme. Was: ${uri}.`);
        }
        return new InMemoryTextResource(uri);
    }
};
InMemoryTextResourceResolver = (0, tslib_1.__decorate)([
    (0, inversify_1.injectable)()
], InMemoryTextResourceResolver);
exports.InMemoryTextResourceResolver = InMemoryTextResourceResolver;
exports.UNTITLED_SCHEME = 'untitled';
let untitledResourceSequenceIndex = 0;
let UntitledResourceResolver = class UntitledResourceResolver {
    constructor() {
        this.resources = new Map();
    }
    has(uri) {
        if (uri.scheme !== exports.UNTITLED_SCHEME) {
            throw new Error('The given uri is not untitled file uri: ' + uri);
        }
        else {
            return this.resources.has(uri.toString());
        }
    }
    async resolve(uri) {
        if (uri.scheme !== exports.UNTITLED_SCHEME) {
            throw new Error('The given uri is not untitled file uri: ' + uri);
        }
        else {
            const untitledResource = this.resources.get(uri.toString());
            if (!untitledResource) {
                return this.createUntitledResource('', '', uri);
            }
            else {
                return untitledResource;
            }
        }
    }
    async createUntitledResource(content, extension, uri) {
        if (!uri) {
            uri = this.createUntitledURI(extension);
        }
        return new UntitledResource(this.resources, uri, content);
    }
    createUntitledURI(extension, parent) {
        let counter = 1; // vscode starts at 1
        let untitledUri;
        do {
            const name = `Untitled-${counter}${extension !== null && extension !== void 0 ? extension : ''}`;
            if (parent) {
                untitledUri = parent.resolve(name).withScheme(exports.UNTITLED_SCHEME);
            }
            untitledUri = new uri_1.default().resolve(name).withScheme(exports.UNTITLED_SCHEME);
            counter++;
        } while (this.has(untitledUri));
        return untitledUri;
    }
};
UntitledResourceResolver = (0, tslib_1.__decorate)([
    (0, inversify_1.injectable)()
], UntitledResourceResolver);
exports.UntitledResourceResolver = UntitledResourceResolver;
class UntitledResource {
    constructor(resources, uri, content) {
        this.resources = resources;
        this.uri = uri;
        this.content = content;
        this.onDidChangeContentsEmitter = new event_1.Emitter();
        this.resources.set(this.uri.toString(), this);
    }
    get onDidChangeContents() {
        return this.onDidChangeContentsEmitter.event;
    }
    dispose() {
        this.resources.delete(this.uri.toString());
        this.onDidChangeContentsEmitter.dispose();
    }
    async readContents(options) {
        if (this.content) {
            return this.content;
        }
        else {
            return '';
        }
    }
    async saveContents(content, options) {
        // This function must exist to ensure readOnly is false for the Monaco editor.
        // However it should not be called because saving 'untitled' is always processed as 'Save As'.
        throw Error('Untitled resources cannot be saved.');
    }
    fireDidChangeContents() {
        this.onDidChangeContentsEmitter.fire(undefined);
    }
    get version() {
        return undefined;
    }
    get encoding() {
        return undefined;
    }
}
exports.UntitledResource = UntitledResource;
/**
 * @deprecated Since 1.27.0. Please use `UntitledResourceResolver.createUntitledURI` instead.
 */
function createUntitledURI(extension, parent) {
    const name = `Untitled-${untitledResourceSequenceIndex++}${extension !== null && extension !== void 0 ? extension : ''}`;
    if (parent) {
        return parent.resolve(name).withScheme(exports.UNTITLED_SCHEME);
    }
    return new uri_1.default().resolve(name).withScheme(exports.UNTITLED_SCHEME);
}
exports.createUntitledURI = createUntitledURI;
//# sourceMappingURL=resource.js.map