@opensumi/ide-workspace 2.12.1-next-079c1930

package/lib/browser/workspace-service.js

@@ -0,0 +1,675 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceService = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const common_1 = require("../common");
+const ide_core_browser_1 = require("@opensumi/ide-core-browser");
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+const ide_file_service_1 = require("@opensumi/ide-file-service");
+const common_2 = require("@opensumi/ide-file-service/lib/common");
+const common_3 = require("@opensumi/ide-file-service/lib/common");
+const workspace_preferences_1 = require("./workspace-preferences");
+const path_1 = require("@opensumi/ide-core-common/lib/path");
+const jsoncparser = (0, tslib_1.__importStar)(require("jsonc-parser"));
+let WorkspaceService = class WorkspaceService {
+    constructor() {
+        this._roots = [];
+        this.deferredRoots = new ide_core_browser_1.Deferred();
+        this._whenReady = new ide_core_browser_1.Deferred();
+        this.toDisposableCollection = new ide_core_browser_1.DisposableCollection();
+        // 映射工作区显示的文字信息
+        this.workspaceToName = {};
+        // 工作区改变事件
+        this.onWorkspaceChangeEmitter = new ide_core_browser_1.Emitter();
+        this.onWorkspaceFileExcludeChangeEmitter = new ide_core_browser_1.Emitter();
+        // 操作中的工作区改变事件
+        this.onWorkspaceLocationChangedEmitter = new ide_core_browser_1.Emitter();
+        this.toDisposeOnWorkspace = new ide_core_browser_1.DisposableCollection();
+        this.rootWatchers = new Map();
+    }
+    init() {
+        this.doInit();
+    }
+    async initFileServiceExclude() {
+        await this.setFileServiceExcludes();
+    }
+    get whenReady() {
+        return this._whenReady.promise;
+    }
+    async doInit() {
+        // 这里的 `appName` 存在默认值
+        this.applicationName = this.appConfig.appName;
+        const wpUriString = this.getDefaultWorkspacePath();
+        this.listenPreference();
+        if (wpUriString) {
+            const wpStat = await this.toFileStat(wpUriString);
+            await this.setWorkspace(wpStat);
+            this.toDisposableCollection.push(this.fileServiceClient.onFilesChanged((event) => {
+                if (this._workspace && common_2.FileChangeEvent.isAffected(event, new ide_core_common_1.URI(this._workspace.uri))) {
+                    this.updateWorkspace();
+                }
+            }));
+        }
+        else {
+            // 处理空工作区情况
+            this.deferredRoots.resolve([]);
+        }
+        this._whenReady.resolve();
+    }
+    getTemporaryWorkspaceFileUri(home) {
+        return home.resolve(this.appConfig.storageDirName || common_1.WORKSPACE_USER_STORAGE_FOLDER_NAME).resolve(`${common_1.UNTITLED_WORKSPACE}.${common_1.KAITIAN_MULTI_WORKSPACE_EXT}`).withScheme('file');
+    }
+    listenPreference() {
+        const watchExcludeName = 'files.watcherExclude';
+        const filesExcludeName = 'files.exclude';
+        const multiRootPrefName = 'workspace.supportMultiRootWorkspace';
+        this.toDisposableCollection.push(this.preferenceService.onPreferenceChanged((e) => {
+            // 工作区切换到多工作区时，可能会触发一次所有工作区配置的 Changed
+            if (e.preferenceName === watchExcludeName) {
+                this.fileServiceClient.setWatchFileExcludes(this.getFlattenExcludes(watchExcludeName));
+            }
+            else if (e.preferenceName === filesExcludeName) {
+                this.fileServiceClient.setFilesExcludes(this.getFlattenExcludes(filesExcludeName), this._roots.map((stat) => {
+                    return stat.uri;
+                })).then(() => {
+                    // 通知目录树更新
+                    this.onWorkspaceFileExcludeChangeEmitter.fire();
+                });
+            }
+            else if (e.preferenceName === multiRootPrefName) {
+                this.updateWorkspace();
+            }
+        }));
+    }
+    async setFileServiceExcludes() {
+        const watchExcludeName = 'files.watcherExclude';
+        const filesExcludeName = 'files.exclude';
+        await this.preferenceService.ready;
+        await this.fileServiceClient.setWatchFileExcludes(this.getFlattenExcludes(watchExcludeName));
+        await this.fileServiceClient.setFilesExcludes(this.getFlattenExcludes(filesExcludeName), this._roots.map((stat) => {
+            return stat.uri;
+        }));
+        this.onWorkspaceFileExcludeChangeEmitter.fire();
+    }
+    getFlattenExcludes(name) {
+        const excludes = [];
+        const fileExcludes = this.preferenceService.get(name);
+        if (fileExcludes) {
+            for (const key of Object.keys(fileExcludes)) {
+                if (fileExcludes[key]) {
+                    excludes.push(key);
+                }
+            }
+        }
+        return excludes;
+    }
+    /**
+     * 获取默认的workspace路径
+     */
+    getDefaultWorkspacePath() {
+        if (this.appConfig.workspaceDir) {
+            // 默认读取传入配置路径
+            let path;
+            try {
+                // 尝试使用 Windows 下带盘符的路径进行解析
+                path = new URL(ide_core_common_1.URI.file(this.appConfig.workspaceDir).codeUri.fsPath).toString();
+            }
+            catch (e) {
+                // 解析失败时仍然使用非 Windows 环境下的解析方式
+                path = ide_core_common_1.URI.file(this.appConfig.workspaceDir).toString();
+            }
+            return path;
+        }
+        else {
+            return undefined;
+        }
+    }
+    get roots() {
+        return this.deferredRoots.promise;
+    }
+    tryGetRoots() {
+        return this._roots;
+    }
+    get workspace() {
+        return this._workspace;
+    }
+    get onWorkspaceChanged() {
+        return this.onWorkspaceChangeEmitter.event;
+    }
+    get onWorkspaceFileExcludeChanged() {
+        return this.onWorkspaceFileExcludeChangeEmitter.event;
+    }
+    get onWorkspaceLocationChanged() {
+        return this.onWorkspaceLocationChangedEmitter.event;
+    }
+    async setWorkspace(workspaceStat) {
+        if (ide_file_service_1.FileStat.equals(this._workspace, workspaceStat)) {
+            return;
+        }
+        this.toDisposeOnWorkspace.dispose();
+        this._workspace = workspaceStat;
+        if (this._workspace) {
+            const uri = new ide_core_common_1.URI(this._workspace.uri);
+            this.toDisposeOnWorkspace.push(await this.fileServiceClient.watchFileChanges(uri));
+        }
+        this.updateTitle();
+        await this.updateWorkspace();
+    }
+    async updateWorkspace() {
+        var _a;
+        if (this._workspace) {
+            this.toFileStat(this._workspace.uri).then((stat) => this._workspace = stat);
+            this.setMostRecentlyUsedWorkspace(this._workspace.uri);
+        }
+        await this.updateRoots();
+        if (!((_a = this._workspace) === null || _a === void 0 ? void 0 : _a.isDirectory)) {
+            // 工作区模式才需要额外监听根目录，否则会出现重复监听问题
+            this.watchRoots();
+        }
+    }
+    async updateRoots() {
+        const newRoots = await this.computeRoots();
+        let rootsChanged = false;
+        if (newRoots.length !== this._roots.length || newRoots.length === 0) {
+            rootsChanged = true;
+        }
+        else {
+            for (const newRoot of newRoots) {
+                if (!this._roots.some((r) => r.uri === newRoot.uri)) {
+                    rootsChanged = true;
+                    break;
+                }
+            }
+        }
+        if (rootsChanged) {
+            this._roots = newRoots;
+            this.deferredRoots.resolve(this._roots); // in order to resolve first
+            this.deferredRoots = new ide_core_browser_1.Deferred();
+            this.deferredRoots.resolve(this._roots);
+            this.onWorkspaceChangeEmitter.fire(this._roots);
+            // 重新根据工作区Roots设置 fileExclude 及 watchExclude
+            this.setFileServiceExcludes();
+        }
+    }
+    async computeRoots() {
+        const roots = [];
+        if (this._workspace) {
+            if (this._workspace.isDirectory) {
+                return [this._workspace];
+            }
+            const workspaceData = await this.getWorkspaceDataFromFile();
+            if (workspaceData) {
+                for (let { path } of workspaceData.folders) {
+                    if (path === '.') {
+                        path = new ide_core_common_1.URI(this._workspace.uri).parent.toString();
+                    }
+                    const valid = await this.toValidRoot(path);
+                    if (valid) {
+                        roots.push(valid);
+                    }
+                    else {
+                        roots.push({
+                            uri: path,
+                            lastModification: Date.now(),
+                            isDirectory: true,
+                        });
+                    }
+                }
+            }
+        }
+        return roots;
+    }
+    async getWorkspaceDataFromFile() {
+        if (this._workspace && await this.fileServiceClient.access(this._workspace.uri)) {
+            if (this._workspace.isDirectory) {
+                return {
+                    folders: [{ path: this._workspace.uri }],
+                };
+            }
+            const { content } = await this.fileServiceClient.resolveContent(this._workspace.uri);
+            const strippedContent = jsoncparser.stripComments(content);
+            const data = jsoncparser.parse(strippedContent);
+            if (data && common_1.WorkspaceData.is(data)) {
+                const stat = await this.fileServiceClient.getFileStat(this._workspace.uri);
+                return common_1.WorkspaceData.transformToAbsolute(data, stat);
+            }
+            this.logger.error(`Unable to retrieve workspace data from the file: '${this._workspace.uri}'. Please check if the file is corrupted.`);
+        }
+    }
+    formatTitle(title) {
+        const name = this.applicationName;
+        let documentTitle = title ? `${title} — ${name}` : name;
+        if (this.appConfig.extensionDevelopmentHost) {
+            documentTitle = `[${(0, ide_core_common_1.localize)('workspace.development.title')}] ${documentTitle}`;
+        }
+        return documentTitle;
+    }
+    // 更新页面Title
+    updateTitle() {
+        // 是否允许按照 workspace dir 修改 document#title
+        if (!this.appConfig.allowSetDocumentTitleFollowWorkspaceDir) {
+            return;
+        }
+        let title;
+        if (this._workspace) {
+            const uri = new ide_core_common_1.URI(this._workspace.uri);
+            const displayName = uri.displayName;
+            if (!this._workspace.isDirectory &&
+                (displayName.endsWith(`.${common_1.KAITIAN_MULTI_WORKSPACE_EXT}`))) {
+                title = (0, ide_core_common_1.formatLocalize)('file.workspace.defaultWorkspaceTip', displayName.slice(0, displayName.lastIndexOf('.')));
+            }
+            else {
+                title = displayName;
+            }
+        }
+        document.title = this.formatTitle(title);
+    }
+    async getMostRecentlyUsedWorkspace() {
+        await this.getGlobalRecentStorage();
+        const recentWorkspaces = await this.recentGlobalStorage.get('RECENT_WORKSPACES') || [];
+        return recentWorkspaces[0];
+    }
+    async setMostRecentlyUsedWorkspace(path) {
+        await this.getGlobalRecentStorage();
+        const recentWorkspaces = await this.recentGlobalStorage.get('RECENT_WORKSPACES') || [];
+        recentWorkspaces.unshift(path);
+        await this.recentGlobalStorage.set('RECENT_WORKSPACES', Array.from(new Set(recentWorkspaces)));
+    }
+    async getMostRecentlyUsedWorkspaces() {
+        await this.getGlobalRecentStorage();
+        const recentWorkspaces = await this.recentGlobalStorage.get('RECENT_WORKSPACES') || [];
+        return recentWorkspaces;
+    }
+    async getMostRecentlyUsedCommands() {
+        await this.getGlobalRecentStorage();
+        const recentCommands = await this.recentGlobalStorage.get('RECENT_COMMANDS') || [];
+        return recentCommands;
+    }
+    async setMostRecentlyUsedCommand(commandId) {
+        await this.getGlobalRecentStorage();
+        const recentCommands = await this.recentGlobalStorage.get('RECENT_COMMANDS') || [];
+        const commandIndex = recentCommands.indexOf(commandId);
+        // 重新排到队列顶部
+        if (commandIndex > 0) {
+            recentCommands.splice(commandIndex, 1);
+        }
+        recentCommands.unshift(commandId);
+        await this.recentGlobalStorage.set('RECENT_COMMANDS', recentCommands);
+    }
+    async getGlobalRecentStorage() {
+        this.recentGlobalStorage = this.recentGlobalStorage || await this.storageProvider(ide_core_common_1.STORAGE_NAMESPACE.GLOBAL_RECENT_DATA);
+        await this.recentGlobalStorage.whenReady;
+        return this.recentGlobalStorage;
+    }
+    /**
+     * 当已经存在打开的工作区时，返回true
+     * @returns {boolean}
+     */
+    get opened() {
+        return !!this._workspace;
+    }
+    /**
+     * 当一个混合工作区打开时，返回 true
+     * @returns {boolean}
+     */
+    get isMultiRootWorkspaceOpened() {
+        return !!this.workspace && !this.workspace.isDirectory;
+    }
+    /**
+     * 当前存在打开的工作区同时支持混合工作区时，返回true
+     * @returns {boolean}
+     */
+    get isMultiRootWorkspaceEnabled() {
+        return this.opened && this.preferences['workspace.supportMultiRootWorkspace'];
+    }
+    /**
+     * 打开一个文件夹或创建一个工作区
+     * @param {URI} uri
+     * @param {WorkspaceInput} [options]
+     * @memberof WorkspaceService
+     */
+    async open(uri, options) {
+        await this.doOpen(uri, options);
+    }
+    /**
+     * 需要判断是否在当前工作区打开窗口
+     * 在这里传入的options优先级高于preference设置
+     * @protected
+     * @param {URI} uri
+     * @param {WorkspaceInput} [options]
+     * @returns {Promise<void>}
+     * @memberof WorkspaceService
+     */
+    async doOpen(uri, options) {
+        const rootUri = uri.toString();
+        const stat = await this.toFileStat(rootUri);
+        if (stat) {
+            await this.roots;
+            const { preserveWindow } = Object.assign({ preserveWindow: this.preferences['workspace.preserveWindow'] || !this.opened }, options);
+            if (preserveWindow) {
+                this._workspace = stat;
+            }
+            this.openWindow(stat, { preserveWindow });
+            return;
+        }
+        throw new Error('Invalid workspace root URI. Expected an existing directory location.');
+    }
+    /**
+     * 为工作区设置根目录
+     * @param uri
+     */
+    async addRoot(uri) {
+        await this.spliceRoots(this._roots.length, 0, {}, uri);
+    }
+    /**
+     * 工作区中移除对应根目录
+     */
+    async removeRoots(uris) {
+        if (!this.opened) {
+            throw new Error('Folder cannot be removed as there is no active folder in the current workspace.');
+        }
+        if (this._workspace) {
+            const workspaceData = await this.getWorkspaceDataFromFile();
+            this._workspace = await this.writeWorkspaceFile(this._workspace, common_1.WorkspaceData.buildWorkspaceData(this._roots.filter((root) => uris.findIndex((u) => u.toString() === root.uri) < 0), workspaceData.settings));
+        }
+    }
+    async spliceRoots(start, deleteCount = 0, workspaceToName = {}, ...rootsToAdd) {
+        if (!this._workspace) {
+            throw new Error('There is not active workspace');
+        }
+        const dedup = new Set();
+        const roots = this._roots.map((root) => (dedup.add(root.uri), root.uri));
+        const toAdd = [];
+        // 更新工作区映射
+        for (const uri of Object.keys(workspaceToName)) {
+            this.workspaceToName[new ide_core_common_1.URI(uri).toString()] = workspaceToName[uri];
+        }
+        for (const root of rootsToAdd) {
+            const uri = root.toString();
+            if (!dedup.has(uri)) {
+                dedup.add(uri);
+                toAdd.push(uri);
+            }
+        }
+        const toRemove = roots.splice(start, deleteCount || 0, ...toAdd);
+        if (!toRemove.length && !toAdd.length) {
+            return [];
+        }
+        if (this._workspace.isDirectory) {
+            const untitledWorkspace = await this.getUntitledWorkspace();
+            if (untitledWorkspace) {
+                await this.save(untitledWorkspace);
+            }
+        }
+        const currentData = await this.getWorkspaceDataFromFile();
+        const newData = common_1.WorkspaceData.buildWorkspaceData(roots, currentData && currentData.settings);
+        await this.writeWorkspaceFile(this._workspace, newData);
+        return toRemove.map((root) => new ide_core_common_1.URI(root));
+    }
+    getWorkspaceName(uri) {
+        return this.workspaceToName[uri.toString()] || this.workspaceToName[uri.toString() + path_1.Path.separator] || uri.displayName;
+    }
+    async getUntitledWorkspace() {
+        const home = await this.fileServiceClient.getCurrentUserHome();
+        return home && this.getTemporaryWorkspaceFileUri(new ide_core_common_1.URI(home.uri));
+    }
+    async writeWorkspaceFile(workspaceFile, workspaceData) {
+        if (workspaceFile) {
+            const data = JSON.stringify(common_1.WorkspaceData.transformToRelative(workspaceData, workspaceFile));
+            const edits = jsoncparser.format(data, undefined, { tabSize: 2, insertSpaces: true, eol: '' });
+            const result = jsoncparser.applyEdits(data, edits);
+            const stat = await this.fileServiceClient.setContent(workspaceFile, result);
+            if (!stat) {
+                return undefined;
+            }
+            return stat;
+        }
+    }
+    /**
+     * 清理当前workspace
+     */
+    async close() {
+        this._workspace = undefined;
+        this._roots.length = 0;
+        this.reloadWindow();
+    }
+    /**
+     * 验证给定的URI是否为有效根目录
+     */
+    async toValidRoot(uri) {
+        const fileStat = await this.toFileStat(uri);
+        if (fileStat && fileStat.isDirectory) {
+            return fileStat;
+        }
+        return undefined;
+    }
+    /**
+     * 返回文件的FileStat
+     */
+    async toFileStat(uri) {
+        if (!uri) {
+            return undefined;
+        }
+        let uriStr = uri.toString();
+        try {
+            if (uriStr.endsWith('/')) {
+                uriStr = uriStr.slice(0, -1);
+            }
+            const fileStat = await this.fileServiceClient.getFileStat(uriStr);
+            if (!fileStat) {
+                return undefined;
+            }
+            return fileStat;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    openWindow(fileStat, options) {
+        const workspacePath = new ide_core_common_1.URI(fileStat.uri).path.toString();
+        if (this.shouldPreserveWindow(options)) {
+            this.reloadWindow();
+        }
+        else {
+            try {
+                this.openNewWindow(workspacePath);
+            }
+            catch (error) {
+                // Fall back to reloading the current window in case the browser has blocked the new window
+                this._workspace = fileStat;
+                this.logger.error(error.toString());
+            }
+        }
+    }
+    reloadWindow() {
+        this.clientApp.fireOnReload(true);
+    }
+    openNewWindow(workspacePath) {
+        const url = new URL(window.location.href);
+        url.hash = workspacePath;
+        this.windowService.openNewWindow(url.toString());
+    }
+    shouldPreserveWindow(options) {
+        return options !== undefined && !!options.preserveWindow;
+    }
+    /**
+     * 返回根目录下是否存在对应相对路径文件
+     */
+    async containsSome(paths) {
+        await this.roots;
+        if (this.opened) {
+            for (const root of this._roots) {
+                const uri = new ide_core_common_1.URI(root.uri);
+                for (const path of paths) {
+                    const fileUri = uri.resolve(path).toString();
+                    const exists = await this.fileServiceClient.access(fileUri);
+                    if (exists) {
+                        return exists;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    get saved() {
+        return !!this._workspace && !this._workspace.isDirectory;
+    }
+    /**
+     * 存储工作区数据到文件中
+     * @param uri URI or FileStat of the workspace file
+     */
+    async save(uri) {
+        const uriStr = uri instanceof ide_core_common_1.URI ? uri.toString() : uri.uri;
+        if (!await this.fileServiceClient.access(uriStr)) {
+            await this.fileServiceClient.createFile(uriStr);
+        }
+        const workspaceData = { folders: [], settings: {} };
+        if (!this.saved) {
+            for (const p of Object.keys(this.schemaProvider.getCombinedSchema().properties)) {
+                if (this.schemaProvider.isValidInScope(p, ide_core_browser_1.PreferenceScope.Folder)) {
+                    continue;
+                }
+                const preferences = this.preferenceService.inspect(p);
+                if (preferences && preferences.workspaceValue) {
+                    workspaceData.settings[p] = preferences.workspaceValue;
+                }
+            }
+        }
+        let stat = await this.toFileStat(uriStr);
+        Object.assign(workspaceData, await this.getWorkspaceDataFromFile());
+        stat = await this.writeWorkspaceFile(stat, common_1.WorkspaceData.buildWorkspaceData(this._roots, workspaceData ? workspaceData.settings : undefined));
+        await this.setWorkspace(stat);
+        this.onWorkspaceLocationChangedEmitter.fire(stat);
+    }
+    // 监听所有根路径变化
+    async watchRoots() {
+        const rootUris = new Set(this._roots.map((r) => r.uri));
+        for (const [uri, watcher] of this.rootWatchers.entries()) {
+            if (!rootUris.has(uri)) {
+                watcher.dispose();
+            }
+        }
+        for (const root of this._roots) {
+            this.watchRoot(root);
+        }
+    }
+    // 监听根路径变化
+    async watchRoot(root) {
+        const uriStr = root.uri;
+        if (this.rootWatchers.has(uriStr)) {
+            return;
+        }
+        const watcher = this.fileServiceClient.watchFileChanges(new ide_core_common_1.URI(root.uri));
+        this.rootWatchers.set(uriStr, ide_core_browser_1.Disposable.create(() => {
+            watcher.then((disposable) => disposable.dispose());
+            this.rootWatchers.delete(uriStr);
+        }));
+    }
+    /**
+     * 根据给定的uri获取其根节点
+     * 如果不指定uri，则获取默认的根节点
+     * @param uri
+     */
+    getWorkspaceRootUri(uri) {
+        // 获取非file协议文件的根目录，默认返回第一个根目录或undefined
+        if (!uri || uri.scheme !== 'file') {
+            const root = this.tryGetRoots()[0];
+            if (root) {
+                return new ide_core_common_1.URI(root.uri);
+            }
+            return undefined;
+        }
+        const rootUris = [];
+        for (const root of this.tryGetRoots()) {
+            const rootUri = new ide_core_common_1.URI(root.uri);
+            if (rootUri && rootUri.isEqualOrParent(uri)) {
+                rootUris.push(rootUri);
+            }
+        }
+        return rootUris.sort((r1, r2) => r2.toString().length - r1.toString().length)[0];
+    }
+    /**
+     * 获取相对路径
+     * @param pathOrUri
+     * @param includeWorkspaceFolder
+     */
+    async asRelativePath(pathOrUri, includeWorkspaceFolder) {
+        // path 为 uri.path 非 uri.toString()
+        let path;
+        if (typeof pathOrUri === 'string') {
+            path = pathOrUri;
+        }
+        else if (typeof pathOrUri !== 'undefined') {
+            path = pathOrUri.codeUri.fsPath;
+        }
+        if (!path) {
+            return path;
+        }
+        const roots = await this.roots;
+        if (includeWorkspaceFolder && this.isMultiRootWorkspaceOpened) {
+            const workspace = await this.workspace;
+            if (workspace) {
+                roots.push(workspace);
+            }
+        }
+        for (const root of roots) {
+            const rootPath = new ide_core_common_1.URI(root.uri).codeUri.fsPath;
+            const isRelative = path && path.indexOf(rootPath) >= 0;
+            if (isRelative) {
+                if (path === rootPath) {
+                    return '';
+                }
+                if (rootPath.slice(-1) === '/') {
+                    return decodeURI(path.replace(rootPath, ''));
+                }
+                return decodeURI(path.replace(rootPath + '/', ''));
+            }
+        }
+        return decodeURI(path);
+    }
+    dispose() {
+        this.toDisposableCollection.dispose();
+    }
+};
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(common_3.IFileServiceClient),
+    (0, tslib_1.__metadata)("design:type", Object)
+], WorkspaceService.prototype, "fileServiceClient", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.IWindowService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], WorkspaceService.prototype, "windowService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.ILogger),
+    (0, tslib_1.__metadata)("design:type", Object)
+], WorkspaceService.prototype, "logger", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(workspace_preferences_1.WorkspacePreferences),
+    (0, tslib_1.__metadata)("design:type", Object)
+], WorkspaceService.prototype, "preferences", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.PreferenceService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], WorkspaceService.prototype, "preferenceService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.PreferenceSchemaProvider),
+    (0, tslib_1.__metadata)("design:type", ide_core_browser_1.PreferenceSchemaProvider)
+], WorkspaceService.prototype, "schemaProvider", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.AppConfig),
+    (0, tslib_1.__metadata)("design:type", Object)
+], WorkspaceService.prototype, "appConfig", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_common_1.StorageProvider),
+    (0, tslib_1.__metadata)("design:type", Function)
+], WorkspaceService.prototype, "storageProvider", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.IClientApp),
+    (0, tslib_1.__metadata)("design:type", Object)
+], WorkspaceService.prototype, "clientApp", void 0);
+WorkspaceService = (0, tslib_1.__decorate)([
+    (0, di_1.Injectable)()
+], WorkspaceService);
+exports.WorkspaceService = WorkspaceService;
+//# sourceMappingURL=workspace-service.js.map