vscode#ConfigurationTarget TypeScript Examples

async set(value: T): Promise<void> {
		const value2 = this.serializer.serializer(value);
		const c = workspace.getConfiguration(undefined, this.scope);
		let target: ConfigurationTarget;
		if (this.target !== undefined) {
			target = this.target;
		} else {
			const result = c.inspect(this.id);
			if (
				result &&
				[
					result.workspaceFolderLanguageValue,
					result.workspaceFolderValue,
				].some((i) => i !== undefined)
			) {
				target = ConfigurationTarget.WorkspaceFolder;
			}
			if (
				result &&
				[result.workspaceLanguageValue, result.workspaceValue].some(
					(i) => i !== undefined
				)
			) {
				target = ConfigurationTarget.Workspace;
			} else {
				target = ConfigurationTarget.Global;
			}
		}

		await c.update(this.id, value2, target);
	}

/**
 * Toggle global setting (cycle through passed values).
 */
export async function toggleGlobalSetting(settingName: string, values: unknown[]) {
	const settings = workspace.getConfiguration(undefined, null);
	const currentSettingValue = settings.get(settingName);

	if (values.length === 1) {
		return settings.update(settingName, values[0], ConfigurationTarget.Global);
	} else {
		const next = getNextOrFirstElement(values, currentSettingValue);
		return settings.update(settingName, next, ConfigurationTarget.Global);
	}
}

updateConfigProperty = async (
  property: string,
  value: unknown,
  target = ConfigurationTarget.Workspace,
) => {
  await workspace.getConfiguration().update(property, value, target);
}

export async function updateJavaHomeWorkspaceConfig(context: ExtensionContext, javaHome: string) {
  if (!javaHome) {
    return;
  }

  const allow = 'Allow';
  const disallow = 'Disallow';

  const key = getKey(IS_WORKSPACE_JDK_ALLOWED, context.storagePath, javaHome);
  const globalState = context.globalState;
  const allowWorkspaceEdit = globalState.get(key);

  if (allowWorkspaceEdit === undefined) {
    await window
      .showWarningMessage(
        `Do you allow Stripe extention to set the ${STRIPE_JAVA_HOME} variable? \n ${STRIPE_JAVA_HOME}: ${javaHome}`,
        disallow,
        allow,
      )
      .then(async (selection) => {
        if (selection === allow) {
          globalState.update(key, true);
          await workspace
            .getConfiguration()
            .update(STRIPE_JAVA_HOME, javaHome, ConfigurationTarget.Global);
        } else if (selection === disallow) {
          globalState.update(key, false);
          // leave the settings unchanged, in case user had manually set it before
        }
      });
  } else if (allowWorkspaceEdit) {
    const javaHomeValue = workspace.getConfiguration().get<string>(STRIPE_JAVA_HOME) || '';
    if (javaHomeValue !== javaHome) {
      await workspace
        .getConfiguration()
        .update(STRIPE_JAVA_HOME, javaHome, ConfigurationTarget.Global);
    }
  }
}

private readValue(): any {
		const config = workspace.getConfiguration(undefined, this.scope);

		if (this.target === undefined) {
			return config.get(this.id);
		} else {
			const result = config.inspect(this.id);
			if (!result) {
				return undefined;
			}
			if (this.target === ConfigurationTarget.Global) {
				return result.globalValue;
			} else if (this.target === ConfigurationTarget.Workspace) {
				return result.workspaceValue;
			} else if (this.target === ConfigurationTarget.WorkspaceFolder) {
				return result.workspaceFolderValue;
			}
		}
	}

constructor(
		readonly id: string,
		options: {
			serializer?: Serializer<T>;
			scope?: Uri;
			target?: ConfigurationTarget;
		} = {}
	) {
		this.scope = options.scope;
		this.serializer = options.serializer || {
			deserialize: (val) => val as T,
			serializer: (val) => val,
		};

		this.target = options.target;
		this.settingResource = new VsCodeSettingResource(
			this.id,
			this.scope,
			this.target
		);
	}

async getConfirmation(): Promise<boolean> {
        return window.showInformationMessage(
            'Start building JSON models?\n\nBuilds from tracked file locations.',
            { modal: true },
            ...['Start', "Don't ask again"]).then((action) => {
                switch (action) {
                    case "Don't ask again":
                        config.setConfig<boolean>('fastMode', true, ConfigurationTarget.Global);
                        return true;
                    case 'Start':
                        return true;
                    default:
                        return false;
                }
            });
    }

private readValue(): any {
		const config = workspace.getConfiguration(undefined, this.scope);

		if (this.target === undefined) {
			return config.get(this.id);
		} else {
			const result = config.inspect(this.id);
			if (!result) {
				return undefined;
			}
			if (this.target === ConfigurationTarget.Global) {
				return result.globalValue;
			} else if (this.target === ConfigurationTarget.Workspace) {
				return result.workspaceValue;
			} else if (this.target === ConfigurationTarget.WorkspaceFolder) {
				return result.workspaceFolderValue;
			}
		}
	}

public constructor(
		public readonly id: string,
		options: {
			serializer?: Serializer<T>;
			scope?: Uri;
			target?: ConfigurationTarget;
		} = {}
	) {
		this.scope = options.scope;
		this.serializer = options.serializer || {
			deserialize: (val) => val,
			serializer: (val) => val,
		};

		this.target = options.target;
		this.settingResource = new VsCodeSettingResource(
			this.id,
			this.scope,
			this.target
		);
	}

public async set(value: T): Promise<void> {
		const value2 = this.serializer.serializer(value);
		const c = workspace.getConfiguration(undefined, this.scope);
		let target: ConfigurationTarget;
		if (this.target !== undefined) {
			target = this.target;
		} else {
			const result = c.inspect(this.id);
			if (
				result &&
				[
					result.workspaceFolderLanguageValue,
					result.workspaceFolderValue,
				].some((i) => i !== undefined)
			) {
				target = ConfigurationTarget.WorkspaceFolder;
			}
			if (
				result &&
				[result.workspaceLanguageValue, result.workspaceValue].some(
					(i) => i !== undefined
				)
			) {
				target = ConfigurationTarget.Workspace;
			} else {
				target = ConfigurationTarget.Global;
			}
		}

		await c.update(this.id, value2, target);
	}

constructor(
		private readonly id: string,
		private readonly scope: Uri | undefined,
		private readonly target: ConfigurationTarget | undefined
	) {}

async setConfig<T>(key: string, value: T, target: ConfigurationTarget): Promise<void> {
        await this.config.update(key, value, target);
    }

updateAlertMissingCredentials(value: boolean): Thenable<void> {
        return settingsGroup().update(MISSING_CREDENTIALS, value, ConfigurationTarget.Global);
    }

private readonly target: ConfigurationTarget | undefined;

private readonly target: ConfigurationTarget | undefined;

constructor(
		private readonly id: string,
		private readonly scope: Uri | undefined,
		private readonly target: ConfigurationTarget | undefined
	) {}

function addToPreferenceArray<T>(key: string, value: T): void {
  const configArray: T[] = workspace.getConfiguration().get<T[]>(key, []);
  if (configArray.includes(value)) {
    return;
  }
  configArray.push(value);
  workspace.getConfiguration().update(key, configArray, ConfigurationTarget.Workspace);
}

private readonly _knownPlugins = new VsCodeSetting<
		{ pluginId: string; fingerprint: string; allowed: boolean }[]
	>(`${extensionId}.knownPlugins`, {
		serializer: serializerWithDefault<any>([]),
		// Don't use workspace settings here!
		target: ConfigurationTarget.Global,
	});

/**
 * Updates global setting with new value.
 */
export async function updateSetting(settingName: string, newValue: unknown) {
	const settings = workspace.getConfiguration(undefined, null);
	return settings.update(settingName, newValue, ConfigurationTarget.Global);
}

/**
   * 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 };
  }