refactor(editor): split Config to VSCodeConfig and WorkspaceConfig

Author: Sysix

editors/vscode/client/Config.ts

@@ -1,19 +1,24 @@
 import { ConfigurationChangeEvent, workspace } from 'vscode';
-import { Config } from './Config';
 import { IDisposable } from './types';
+import { VSCodeConfig } from './VSCodeConfig';
+import { WorkspaceConfig } from './WorkspaceConfig';
 
 export class ConfigService implements IDisposable {
-  private static readonly _namespace = 'oxc';
+  public static readonly namespace = 'oxc';
   private readonly _disposables: IDisposable[] = [];
 
-  public config: Config;
+  public vsCodeConfig: VSCodeConfig;
+
+  private _workspaceConfig: WorkspaceConfig;
 
   public onConfigChange:
     | ((this: ConfigService, config: ConfigurationChangeEvent) => Promise<void>)
     | undefined;
 
   constructor() {
-    this.config = new Config();
+    const conf = workspace.getConfiguration(ConfigService.namespace);
+    this.vsCodeConfig = new VSCodeConfig(conf);
+    this._workspaceConfig = new WorkspaceConfig(conf);
     this.onConfigChange = undefined;
 
     const disposeChangeListener = workspace.onDidChangeConfiguration(
@@ -22,9 +27,19 @@ export class ConfigService implements IDisposable {
     this._disposables.push(disposeChangeListener);
   }
 
+  public get rootServerConfig(): WorkspaceConfig {
+    return this._workspaceConfig;
+  }
+
+  public refresh(): void {
+    const conf = workspace.getConfiguration(ConfigService.namespace);
+    this.vsCodeConfig.refresh(conf);
+    this.rootServerConfig.refresh(conf);
+  }
+
   private async onVscodeConfigChange(event: ConfigurationChangeEvent): Promise<void> {
-    if (event.affectsConfiguration(ConfigService._namespace)) {
-      this.config.refresh();
+    if (event.affectsConfiguration(ConfigService.namespace)) {
+      this.refresh();
       await this.onConfigChange?.(event);
     }
   }

editors/vscode/client/ConfigService.ts

@@ -0,0 +1,45 @@
+import { strictEqual } from 'assert';
+import { Uri, workspace, WorkspaceEdit } from 'vscode';
+import { VSCodeConfig } from './VSCodeConfig.js';
+
+const conf = workspace.getConfiguration('oxc');
+
+suite('Config', () => {
+  setup(async () => {
+    const keys = ['enable', 'trace.server', 'path.server'];
+
+    await Promise.all(keys.map(key => conf.update(key, undefined)));
+  });
+
+  suiteTeardown(async () => {
+    const WORKSPACE_DIR = workspace.workspaceFolders![0].uri.toString();
+    const file = Uri.parse(WORKSPACE_DIR + '/.vscode/settings.json');
+    const edit = new WorkspaceEdit();
+    edit.deleteFile(file);
+    await workspace.applyEdit(edit);
+  });
+
+  test('default values on initialization', () => {
+    const config = new VSCodeConfig(conf);
+
+    strictEqual(config.enable, true);
+    strictEqual(config.trace, 'off');
+    strictEqual(config.binPath, '');
+  });
+
+  test('updating values updates the workspace configuration', async () => {
+    const config = new VSCodeConfig(conf);
+
+    await Promise.all([
+      config.updateEnable(false),
+      config.updateTrace('messages'),
+      config.updateBinPath('./binary'),
+    ]);
+
+    const wsConfig = workspace.getConfiguration('oxc');
+
+    strictEqual(wsConfig.get('enable'), false);
+    strictEqual(wsConfig.get('trace.server'), 'messages');
+    strictEqual(wsConfig.get('path.server'), './binary');
+  });
+});

editors/vscode/client/VSCodeConfig.spec.ts

@@ -0,0 +1,79 @@
+import { workspace, WorkspaceConfiguration } from 'vscode';
+import { ConfigService } from './ConfigService';
+
+export const oxlintConfigFileName = '.oxlintrc.json';
+
+export class VSCodeConfig implements VSCodeConfigInterface {
+  private _enable!: boolean;
+  private _trace!: TraceLevel;
+  private _binPath: string | undefined;
+
+  constructor(configuration: WorkspaceConfiguration) {
+    this.refresh(configuration);
+  }
+
+  public refresh(configuration: WorkspaceConfiguration): void {
+    this._enable = configuration.get<boolean>('enable') ?? true;
+    this._trace = configuration.get<TraceLevel>('trace.server') || 'off';
+    this._binPath = configuration.get<string>('path.server');
+  }
+
+  get enable(): boolean {
+    return this._enable;
+  }
+
+  updateEnable(value: boolean): PromiseLike<void> {
+    this._enable = value;
+    return workspace
+      .getConfiguration(ConfigService.namespace)
+      .update('enable', value);
+  }
+
+  get trace(): TraceLevel {
+    return this._trace;
+  }
+
+  updateTrace(value: TraceLevel): PromiseLike<void> {
+    this._trace = value;
+    return workspace
+      .getConfiguration(ConfigService.namespace)
+      .update('trace.server', value);
+  }
+
+  get binPath(): string | undefined {
+    return this._binPath;
+  }
+
+  updateBinPath(value: string | undefined): PromiseLike<void> {
+    this._binPath = value;
+    return workspace
+      .getConfiguration(ConfigService.namespace)
+      .update('path.server', value);
+  }
+}
+
+type TraceLevel = 'off' | 'messages' | 'verbose';
+/**
+ * See `"contributes.configuration"` in `package.json`
+ */
+interface VSCodeConfigInterface {
+  /**
+   * `oxc.enable`
+   *
+   * @default true
+   */
+  enable: boolean;
+  /**
+   * Trace VSCode <-> Oxc Language Server communication
+   * `oxc.trace.server`
+   *
+   * @default 'off'
+   */
+  trace: TraceLevel;
+  /**
+   * Path to LSP binary
+   * `oxc.path.server`
+   * @default undefined
+   */
+  binPath: string | undefined;
+}