vscode#WorkspaceConfiguration TypeScript Examples

/**
     * Get configuration value for given configuration parameter.
     * @param configParam Configuration Parameter to retrieve value from.
     * @param fileUri URI to actual file or undefined.
     */
    private static GetConfigurationValue(configParam: string, fileUri: Uri | undefined = undefined): any {
        let config: WorkspaceConfiguration | undefined = this.GetConfiguration(fileUri);
        if (config === undefined) {
            return;
        }
        return config.get(configParam);
    }

/**
     * Get Configuration related for the actual file opened.
     * @param fileUri URI to actual file or undefined.
     */
    private static GetConfiguration(fileUri: Uri | undefined = undefined): WorkspaceConfiguration | undefined {
        let config: WorkspaceConfiguration | undefined;
        if (fileUri === undefined) {
            let activeDocument = (window.activeTextEditor !== undefined) ? window.activeTextEditor.document : undefined;
            let workspaceFolder: WorkspaceFolder | undefined = undefined;
            if (activeDocument !== undefined) {
                workspaceFolder = workspace.getWorkspaceFolder(activeDocument.uri);
                config = workspace.getConfiguration(ALXmlDocConfigurationPrefix, workspaceFolder);
            } else {
                config = workspace.getConfiguration(ALXmlDocConfigurationPrefix);
            }
        } else {
            let workspaceFolder = workspace.getWorkspaceFolder(fileUri);
            config = workspace.getConfiguration(ALXmlDocConfigurationPrefix, workspaceFolder);
        }

        return config;
    }

/**
     * Sets configuration value for given configuration parameter.
     * @param configParam Configuration Parameter to set value.
     * @param configValue New Configuration Value.
     */
    private static SetConfigurationValue(configParam: string, configValue: any) {
        let config: WorkspaceConfiguration | undefined = this.GetConfiguration();
        if (config === undefined) {
            workspace.getConfiguration(ALXmlDocConfigurationPrefix).update(configParam, configValue);
            return;
        }

        config.update(configParam, configValue);
    }

function transform(wsConfig: WorkspaceConfiguration) {
  const { detectIndentation, insertSpaces, tabSize, codeActionsOnSave } =
    wsConfig.get<VscEditorConfig>('editor') ?? {};
  // If 'detectIndentation' is true, indentation is detected instead of from settings.
  const tabType =
    detectIndentation || insertSpaces === undefined
      ? undefined
      : insertSpaces
      ? ('space' as const)
      : ('tab' as const);
  const actionId = SortActionProvider.ACTION_ID;
  const codeAction =
    codeActionsOnSave &&
    (Array.isArray(codeActionsOnSave)
      ? codeActionsOnSave.includes(actionId)
      : codeActionsOnSave[actionId]);
  const { insertFinalNewline: nl, eol } = wsConfig.get<VscFilesConfig>('files') ?? {};
  return {
    config: {
      tabType,
      tabSize: detectIndentation ? undefined : tabSize,
      insertFinalNewline: nl ? true : ('preserve' as const),
      eof: eol === 'auto' ? undefined : eol,
    },
    codeAction,
  };
}

private _config: WorkspaceConfiguration;

config: WorkspaceConfiguration

public config: WorkspaceConfiguration;

private config: WorkspaceConfiguration;

constructor(public config: WorkspaceConfiguration) {}

private shouldActivateAdapterForWorkspaceFolder(
    workspaceFolderPath: string,
    config: WorkspaceConfiguration
  ): boolean {
    const enableExtension = config.get<boolean | null>(WorkspaceConfigSetting.EnableExtension);

    if (typeof enableExtension === 'boolean') {
      this.logger.debug(
        () =>
          `${enableExtension ? 'Including' : 'Excluding'} projects in workspace ` +
          `folder '${workspaceFolderPath}' because the extension has been ` +
          `explicitly ${enableExtension ? 'enabled' : 'disabled'} by setting the ` +
          `'${EXTENSION_CONFIG_PREFIX}.${WorkspaceConfigSetting.EnableExtension}' ` +
          `setting to ${enableExtension ? 'true' : 'false'}`
      );
      return enableExtension;
    }

    const configuredExtensionSetting = Object.values(WorkspaceConfigSetting).find(
      configSetting => config.inspect(configSetting)?.workspaceFolderValue ?? false
    );

    if (configuredExtensionSetting !== undefined) {
      this.logger.debug(
        () =>
          `Including projects in workspace folder '${workspaceFolderPath}' ` +
          `because it has one or more extension settings configured: ` +
          `${configuredExtensionSetting}`
      );
      return true;
    }

    const projectRootPath = config.get<string>(WorkspaceConfigSetting.ProjectRootPath) ?? '';
    const projectPackageJsonFilePath = posix.join(workspaceFolderPath, projectRootPath, 'package.json');
    const workspacePackageJsonFilePath = posix.join(workspaceFolderPath, 'package.json');

    let packageJsonFilePath: string | undefined;

    try {
      if (existsSync(projectPackageJsonFilePath)) {
        packageJsonFilePath = projectPackageJsonFilePath;
      }
    } catch (error) {
      this.logger.debug(() => `Could not find a project package.json file at ${projectPackageJsonFilePath}`);
    }

    try {
      if (!packageJsonFilePath && existsSync(workspacePackageJsonFilePath)) {
        packageJsonFilePath = workspacePackageJsonFilePath;
      }
    } catch (error) {
      this.logger.debug(() => `Could not find a workspace package.json file at ${workspacePackageJsonFilePath}`);
    }

    const packageJson: { devDependencies: Record<string, string> } | undefined = packageJsonFilePath
      ? require(projectPackageJsonFilePath)
      : undefined;

    if (packageJson && Object.keys(packageJson.devDependencies).includes('karma')) {
      this.logger.debug(
        () =>
          `Including projects in workspace folder '${workspaceFolderPath}' ` +
          `because related package.json file '${packageJsonFilePath}' has a karma dev dependency`
      );
      return true;
    }
    return false;
  }

private config: WorkspaceConfiguration;

private goPlusConfig: WorkspaceConfiguration | undefined;

constructor(goPlusConfig?: WorkspaceConfiguration) {
		this.goPlusConfig = goPlusConfig;
	}

getWorkspaceConfig(): WorkspaceConfiguration {
    // TODO: the old implementation of this was wrong - it did not return WorkspaceConfiguration but a WorkspaceSettings object
    // since this doesn't seem to be used, just adding an exception here for future work
    throw Error("not implemented");
  }

/**
   * Upgrade config
   * @param config config to upgrade
   * @param target: config set to upgrade to
   */
  static async upgrade(
    src: WorkspaceConfiguration,
    target: ConfigUpdateChangeSet,
    opts?: SettingsUpgradeOpts
  ): Promise<ConfigChanges> {
    const cleanOpts = _.defaults(opts, { force: false });
    const add: any = {};
    const errors: any = {};
    await Promise.all(
      _.map(
        _.omit(target, [
          "workbench.colorTheme",
          "[markdown]",
          CONFIG.DEFAULT_JOURNAL_DATE_FORMAT.key,
          CONFIG.DEFAULT_SCRATCH_DATE_FORMAT.key,
        ]),
        async (entry, key) => {
          const item = src.inspect(key);
          // if value for key is not defined anywhere, set it to the default
          if (
            _.every(
              [
                item?.globalValue,
                item?.workspaceFolderValue,
                item?.workspaceValue,
              ],
              _.isUndefined
            ) ||
            cleanOpts.force
          ) {
            const value = entry.default;
            try {
              src.update(key, value, ConfigurationTarget.Workspace);
              add[key] = value;
              return;
            } catch (err) {
              errors[key] = err;
            }
          }
          return;
        }
      )
    );
    return { add, errors };
  }

FOREIGN = (conf: WorkspaceConfiguration): boolean =>
  conf.get("network.foreignUser", false)

HTTPS_API = (conf: WorkspaceConfiguration): boolean =>
  conf.get("network.httpsAPI", true)

MUSIC_CACHE_SIZE = (conf: WorkspaceConfiguration): number =>
  conf.get("cache.size", 4096) * 1024 * 1024

MUSIC_QUALITY = (conf: WorkspaceConfiguration): number =>
  conf.get<128000 | 192000 | 320000 | 999000>("music.quality", 192000)

CONF = (): WorkspaceConfiguration =>
  workspace.getConfiguration("cloudmusic")

function settingsGroup(): WorkspaceConfiguration {
    return workspace.getConfiguration(EXTENSION_SETTINGS_GROUP);
}