@opensumi/ide-workspace 2.21.13 → 2.22.0

package/src/browser/workspace-storage-service.ts

@@ -0,0 +1,64 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { GlobalBrowserStorageService } from '@opensumi/ide-core-browser/lib/services';
+import { FileStat } from '@opensumi/ide-file-service';
+
+import { IWorkspaceService, IWorkspaceStorageService } from '../common';
+
+/*
+ * 为存在 Browser (LocalStorage) 的数据添加命名空间
+ * @Deprecated
+ */
+@Injectable()
+export class WorkspaceStorageService implements IWorkspaceStorageService {
+  private prefix: string;
+  private initialized: Promise<void>;
+
+  @Autowired(GlobalBrowserStorageService)
+  protected globalStorageService: GlobalBrowserStorageService;
+
+  @Autowired(IWorkspaceService)
+  protected workspaceService: IWorkspaceService;
+
+  constructor() {
+    this.init();
+  }
+
+  protected init() {
+    this.initialized = this.workspaceService.roots.then(() => {
+      this.updatePrefix();
+      this.workspaceService.onWorkspaceLocationChanged(() => this.updatePrefix());
+    });
+  }
+
+  async setData<T>(key: string, data: T): Promise<void> {
+    if (!this.prefix) {
+      await this.initialized;
+    }
+    const fullKey = this.prefixWorkspaceURI(key);
+    return this.globalStorageService.setData(fullKey, data);
+  }
+
+  async getData<T>(key: string, defaultValue?: T): Promise<T | undefined> {
+    await this.initialized;
+    const fullKey = this.prefixWorkspaceURI(key);
+    return this.globalStorageService.getData(fullKey, defaultValue);
+  }
+
+  async removeData(key: string): Promise<void> {
+    await this.initialized;
+    const fullKey = this.prefixWorkspaceURI(key);
+    return this.globalStorageService.removeData(fullKey);
+  }
+
+  protected prefixWorkspaceURI(originalKey: string): string {
+    return `${this.prefix}:${originalKey}`;
+  }
+
+  protected getPrefix(workspaceStat: FileStat | undefined): string {
+    return workspaceStat ? workspaceStat.uri : '_global_';
+  }
+
+  private updatePrefix(): void {
+    this.prefix = this.getPrefix(this.workspaceService.workspace);
+  }
+}

package/src/browser/workspace-variable-contribution.ts

@@ -0,0 +1,133 @@
+import { Autowired } from '@opensumi/di';
+import {
+  VariableContribution,
+  VariableRegistry,
+  Domain,
+  URI,
+  CommandService,
+  EDITOR_COMMANDS,
+  COMMON_COMMANDS,
+} from '@opensumi/ide-core-browser';
+
+import { IWorkspaceService } from '../common';
+
+@Domain(VariableContribution)
+export class WorkspaceVariableContribution implements VariableContribution {
+  @Autowired(IWorkspaceService)
+  protected readonly workspaceService: IWorkspaceService;
+
+  @Autowired(CommandService)
+  protected readonly commandService: CommandService;
+
+  registerVariables(variables: VariableRegistry): void {
+    variables.registerVariable({
+      name: 'workspaceRoot',
+      description: 'The path of the workspace root folder',
+      resolve: (context?: URI) => {
+        const uri = this.getWorkspaceRootUri(context);
+        return uri && uri.path.toString();
+      },
+    });
+    variables.registerVariable({
+      name: 'workspaceFolder',
+      description: 'The path of the workspace root folder',
+      resolve: (context?: URI) => {
+        const uri = this.getWorkspaceRootUri(context);
+        return uri && uri.codeUri.fsPath.toString();
+      },
+    });
+    variables.registerVariable({
+      name: 'workspaceFolderBasename',
+      description: 'The name of the workspace root folder',
+      resolve: (context?: URI) => {
+        const uri = this.getWorkspaceRootUri(context);
+        return uri && uri.displayName;
+      },
+    });
+    variables.registerVariable({
+      name: 'cwd',
+      description: 'The path of the current working directory',
+      resolve: (context?: URI) => {
+        const uri = this.getWorkspaceRootUri(context);
+        return (uri && uri.codeUri.fsPath.toString()) || '';
+      },
+    });
+    variables.registerVariable({
+      name: 'file',
+      description: 'The path of the currently opened file',
+      resolve: async () => {
+        const uri = await this.getResourceUri();
+        return uri && uri.codeUri.fsPath.toString();
+      },
+    });
+    variables.registerVariable({
+      name: 'fileBasename',
+      description: 'The basename of the currently opened file',
+      resolve: async () => {
+        const uri = await this.getResourceUri();
+        return uri && uri.path.base;
+      },
+    });
+    variables.registerVariable({
+      name: 'fileBasenameNoExtension',
+      description: "The currently opened file's name without extension",
+      resolve: async () => {
+        const uri = await this.getResourceUri();
+        return uri && uri.path.name;
+      },
+    });
+    variables.registerVariable({
+      name: 'fileDirname',
+      description: "The name of the currently opened file's directory",
+      resolve: async () => {
+        const uri = await this.getResourceUri();
+        return uri && uri.path.dir.toString();
+      },
+    });
+    variables.registerVariable({
+      name: 'fileExtname',
+      description: 'The extension of the currently opened file',
+      resolve: async () => {
+        const uri = await this.getResourceUri();
+        return uri && uri.path.ext;
+      },
+    });
+    variables.registerVariable({
+      name: 'relativeFile',
+      description: "The currently opened file's path relative to the workspace root",
+      resolve: async () => {
+        const uri = await this.getResourceUri();
+        return uri && this.getWorkspaceRelativePath(uri);
+      },
+    });
+    variables.registerVariable({
+      name: 'env',
+      resolve: async () => {
+        const envVariable = await this.commandService.executeCommand<{ [x: string]: string | undefined }>(
+          COMMON_COMMANDS.ENVIRONMENT_VARIABLE.id,
+        );
+        return envVariable;
+      },
+    });
+  }
+
+  getWorkspaceRootUri(uri?: URI): URI | undefined {
+    return this.workspaceService.getWorkspaceRootUri(uri);
+  }
+
+  async getResourceUri(): Promise<URI | undefined> {
+    const currentResource = await this.commandService.executeCommand<{ uri: URI }>(
+      EDITOR_COMMANDS.GET_CURRENT_RESOURCE.id,
+    );
+    if (currentResource) {
+      return currentResource.uri;
+    }
+    return undefined;
+  }
+
+  getWorkspaceRelativePath(uri: URI): string | undefined {
+    const workspaceRootUri = this.getWorkspaceRootUri(uri);
+    const path = workspaceRootUri && workspaceRootUri.path.relative(uri.path);
+    return path && path.toString();
+  }
+}

package/src/common/constants.ts

@@ -0,0 +1,4 @@
+export const DEFAULT_WORKSPACE_SUFFIX_NAME = 'sumi-workspace';
+export const WORKSPACE_USER_STORAGE_FOLDER_NAME = '.sumi';
+export const WORKSPACE_RECENT_DATA_FILE = 'recentdata.json';
+export const UNTITLED_WORKSPACE = 'Untitled';

package/src/common/index.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './workspace.interface';

package/src/common/mocks/index.ts

@@ -0,0 +1 @@
+export * from './workspace-service';

package/src/common/mocks/workspace-service.ts

@@ -0,0 +1,132 @@
+import { Injectable } from '@opensumi/di';
+import { Emitter, URI, Deferred } from '@opensumi/ide-core-common';
+import { FileStat } from '@opensumi/ide-file-service';
+
+import { IWorkspaceService } from '../../common';
+
+@Injectable()
+export class MockWorkspaceService implements IWorkspaceService {
+  private _roots: FileStat[] = [];
+
+  private _workspace: FileStat | undefined;
+
+  isMultiRootWorkspaceOpened = false;
+
+  whenReady: Promise<void>;
+
+  private deferredRoots = new Deferred<FileStat[]>();
+
+  constructor() {
+    this.whenReady = this.init();
+  }
+
+  async init() {
+    await this.setWorkspace();
+  }
+
+  async initFileServiceExclude() {
+    // do nothing
+  }
+
+  async setWorkspace(workspaceStat?: FileStat | undefined) {
+    await this.updateWorkspace(workspaceStat);
+  }
+
+  async updateWorkspace(workspaceStat?: FileStat | undefined) {
+    await this.updateRoots(workspaceStat);
+    this._onWorkspaceChanged.fire(this._roots);
+  }
+
+  containsSome(paths: string[]): Promise<boolean> {
+    throw new Error('Method not implemented.');
+  }
+
+  get roots(): Promise<FileStat[]> {
+    return this.deferredRoots.promise;
+  }
+
+  get workspace(): FileStat | undefined {
+    return this._workspace;
+  }
+
+  tryGetRoots(): FileStat[] {
+    return this._roots;
+  }
+
+  protected async updateRoots(workspaceStat?: FileStat | undefined): Promise<void> {
+    const root: FileStat = workspaceStat || {
+      isDirectory: true,
+      uri: 'file://userhome/',
+      lastModification: 0,
+    };
+    this._workspace = root;
+    this._roots = [root];
+    this.deferredRoots = new Deferred<FileStat[]>();
+    this.deferredRoots.resolve(this._roots);
+    this._onWorkspaceChanged.fire(this._roots);
+  }
+
+  _onWorkspaceChanged: Emitter<FileStat[]> = new Emitter();
+  onWorkspaceChanged = this._onWorkspaceChanged.event;
+
+  _onWorkspaceLocationChanged: Emitter<FileStat | undefined> = new Emitter();
+  onWorkspaceLocationChanged = this._onWorkspaceLocationChanged.event;
+
+  _onWorkspaceFileExcludeChangeEmitter: Emitter<void> = new Emitter();
+  onWorkspaceFileExcludeChanged = this._onWorkspaceFileExcludeChangeEmitter.event;
+
+  async setMostRecentlyUsedWorkspace(): Promise<void> {
+    return;
+  }
+  getMostRecentlyUsedWorkspace(): Promise<string> {
+    throw new Error('Method not implemented.');
+  }
+  getMostRecentlyUsedWorkspaces(): Promise<string[]> {
+    throw new Error('Method not implemented.');
+  }
+  getMostRecentlyUsedCommands(): Promise<string[]> {
+    throw new Error('Method not implemented.');
+  }
+  setMostRecentlyUsedCommand(commandId: string): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  async setMostRecentlyOpenedFile(uri: string): Promise<void> {
+    return;
+  }
+  getMostRecentlyOpenedFiles(): Promise<string[] | undefined> {
+    throw new Error('Method not implemented.');
+  }
+  setMostRecentlySearchWord(word: string | string[]): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  getMostRecentlySearchWord(): Promise<string[] | undefined> {
+    throw new Error('Method not implemented.');
+  }
+  async removeRoots(uri: URI[]) {
+    return;
+  }
+  async spliceRoots(
+    start: number,
+    deleteCount?: number | undefined,
+    workspaceName?: { [key: string]: string },
+    ...rootsToAdd: URI[]
+  ): Promise<URI[]> {
+    this._roots = rootsToAdd.map((root) => ({ isDirectory: true, uri: root.toString(), lastModification: 0 }));
+    this.deferredRoots = new Deferred();
+    this.deferredRoots.resolve(this._roots);
+    return rootsToAdd;
+  }
+  asRelativePath(
+    pathOrUri: string | URI,
+    includeWorkspaceFolder?: boolean | undefined,
+  ): Promise<{ path?: string; root?: string } | undefined> {
+    throw new Error('Method not implemented.');
+  }
+  getWorkspaceRootUri(uri: URI | undefined): URI | undefined {
+    return new URI(this._roots[0].uri);
+  }
+  getWorkspaceName(uri: URI): string {
+    return '';
+  }
+  isMultiRootWorkspaceEnabled: boolean;
+}

package/src/common/workspace.interface.ts

@@ -0,0 +1,75 @@
+import { StorageService } from '@opensumi/ide-core-browser/lib/services';
+import { URI, Event } from '@opensumi/ide-core-common';
+import { FileStat } from '@opensumi/ide-file-service';
+
+export interface WorkspaceInput {
+  /**
+   * 判断是否复用相同窗口
+   */
+  preserveWindow?: boolean;
+}
+
+export const IWorkspaceService = Symbol('IWorkspaceService');
+
+export interface IWorkspaceService {
+  // 获取当前的根节点
+  roots: Promise<FileStat[]>;
+  // 获取workspace
+  workspace: FileStat | undefined;
+  // 当一个混合工作区打开时，返回 true
+  isMultiRootWorkspaceOpened: boolean;
+  whenReady: Promise<void>;
+  // 返回根目录下是否存在对应相对路径文件
+  containsSome(paths: string[]): Promise<boolean>;
+  // 尝试获取根路径数组
+  tryGetRoots(): FileStat[];
+  // 工作区改变事件
+  onWorkspaceChanged: Event<FileStat[]>;
+  /**
+   * 工作区的 files.exclude 配置发生变化
+   */
+  onWorkspaceFileExcludeChanged: Event<void>;
+  /**
+   * 操作中的工作区改变事件
+   * 如：用户添加目录到当前workspace中触发
+   */
+  onWorkspaceLocationChanged: Event<FileStat | undefined>;
+  // 获取最近使用的命令
+  getMostRecentlyUsedCommands(): Promise<string[]>;
+  // 设置最近使用的command
+  setMostRecentlyUsedCommand(commandId: string): Promise<void>;
+  // 获取最近的多个工作区
+  getMostRecentlyUsedWorkspaces(): Promise<string[]>;
+  // 获取最近的一个工作区
+  getMostRecentlyUsedWorkspace(): Promise<string | undefined>;
+  // 设置最近使用的工作区
+  setMostRecentlyUsedWorkspace(uri: string): Promise<void>;
+  // 操作工作区目录
+  spliceRoots(
+    start: number,
+    deleteCount?: number,
+    workspaceToName?: { [key: string]: string },
+    ...rootsToAdd: URI[]
+  ): Promise<URI[]>;
+  // 从工作区中移除目录
+  removeRoots(roots: URI[]): Promise<void>;
+  // 获取相对于工作区的路径
+  asRelativePath(
+    pathOrUri: string | URI,
+    includeWorkspaceFolder?: boolean,
+  ): Promise<{ path?: string; root?: string } | undefined>;
+  // 根据给定的uri获取其根节点
+  getWorkspaceRootUri(uri: URI | undefined): URI | undefined;
+  // 获取工作区名称
+  getWorkspaceName(uri: URI): string;
+  // 当前存在打开的工作区同时支持混合工作区时，返回true
+  isMultiRootWorkspaceEnabled: boolean;
+  // 设置新的工作区
+  setWorkspace(workspaceStat: FileStat | undefined): Promise<void>;
+  // 初始化文件服务中 `files.exclude` 和 `watche.exclude` 配置
+  initFileServiceExclude(): Promise<void>;
+}
+
+export const IWorkspaceStorageService = Symbol('IWorkspaceStorageService');
+
+export type IWorkspaceStorageService = StorageService;

package/src/index.ts

@@ -0,0 +1 @@
+export * from './common';