@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/plugin/plugin-settings-tab.mjs

@@ -0,0 +1,535 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  convertAsyncToSync,
+  invokeAsyncSafely
+} from "@mnaoumov/typescript-lib/async";
+import { mixinAsyncEvents } from "@mnaoumov/typescript-lib/async-events";
+import {
+  noop,
+  noopAsync
+} from "@mnaoumov/typescript-lib/function";
+import {
+  castTo,
+  isDeepEqual,
+  normalizeOptionalProperties
+} from "@mnaoumov/typescript-lib/object-utils";
+import { assertNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  debounce,
+  PluginSettingTab,
+  setTooltip
+} from "obsidian";
+import { registerAsyncEvent } from "../components/async-events-component.mjs";
+import { ComponentEx } from "../components/component-ex.mjs";
+import { CssClass } from "../css-class.mjs";
+import { ensureWrapped } from "../setting-components/setting-component-wrapper.mjs";
+import { getTextBasedComponentValue } from "../setting-components/text-based-component.mjs";
+import { getValidatorComponent } from "../setting-components/validator-component.mjs";
+import { adoptSettingEx } from "../setting-ex.mjs";
+import { isValidationMessageHolder } from "../validation.mjs";
+import { addPluginCssClasses } from "./plugin-context.mjs";
+const SAVE_TO_FILE_CONTEXT = "PluginSettingsTab";
+class PluginSettingsTabEventsComponent extends ComponentEx {
+  params;
+  /**
+   * Creates a new component.
+   *
+   * @param params - The params.
+   */
+  constructor(params) {
+    super();
+    this.params = params;
+  }
+  /**
+   * Subscribes to the settings component's events.
+   */
+  onload() {
+    super.onload();
+    const { pluginSettingsComponent } = this.params;
+    registerAsyncEvent(this, pluginSettingsComponent.on("loadSettings", (loadedState, isInitialLoad) => this.params.onLoadSettings(loadedState, isInitialLoad)));
+    registerAsyncEvent(this, pluginSettingsComponent.on("saveSettings", (newState, oldState, context) => this.params.onSaveSettings(newState, oldState, context)));
+  }
+}
+class PluginSettingsTabBase extends mixinAsyncEvents()(PluginSettingTab) {
+  /**
+   * Whether the plugin settings tab is open.
+   *
+   * @returns Whether the plugin settings tab is open.
+   */
+  get isOpen() {
+    return this._isOpen;
+  }
+  /**
+   * The settings manager.
+   */
+  pluginSettingsComponent;
+  /**
+   * A debounce timeout for saving settings.
+   *
+   * @returns The debounce timeout for saving settings.
+   */
+  get saveSettingsDebounceTimeoutInMilliseconds() {
+    const DEFAULT = 2e3;
+    return DEFAULT;
+  }
+  _isOpen = false;
+  component;
+  currentRenderComponent = null;
+  saveSettingsDebounced;
+  get pluginSettings() {
+    return this.pluginSettingsComponent.settingsState.inputValues;
+  }
+  /**
+   * Creates a new plugin settings tab.
+   *
+   * @param params - The params.
+   */
+  constructor(params) {
+    super(params.plugin.app, params.plugin);
+    this.pluginSettingsComponent = params.pluginSettingsComponent;
+    addPluginCssClasses(this.containerEl, CssClass.PluginSettingsTab);
+    this.saveSettingsDebounced = debounce(
+      convertAsyncToSync(() => this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT)),
+      this.saveSettingsDebounceTimeoutInMilliseconds
+    );
+    this.component = new PluginSettingsTabEventsComponent({
+      onLoadSettings: (loadedState, isInitialLoad) => this.onLoadSettings(loadedState, isInitialLoad),
+      onSaveSettings: (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState }),
+      pluginSettingsComponent: this.pluginSettingsComponent
+    });
+  }
+  /**
+   * Binds a value component to a plugin setting.
+   *
+   * @typeParam UIValue - The type of the value of the UI component.
+   * @typeParam TValueComponent - The type of the value component.
+   * @typeParam PropertyName - The property name of the plugin settings to bind to.
+   * @param params - The params for binding the value component.
+   * @returns The value component.
+   */
+  bind(params) {
+    const {
+      propertyName,
+      valueComponent,
+      ...options
+    } = params;
+    const DEFAULT_OPTIONS = {
+      componentToPluginSettingsValueConverter: (value) => value,
+      onChanged: noop,
+      pluginSettingsToComponentValueConverter: (value) => value,
+      shouldResetSettingWhenComponentIsEmpty: true,
+      shouldShowPlaceholderForDefaultValues: true,
+      shouldShowValidationMessage: true
+    };
+    const optionsExtension = { ...DEFAULT_OPTIONS, ...options };
+    const validatorEl = getValidatorComponent(valueComponent)?.validatorEl;
+    const textBasedComponent = getTextBasedComponentValue(valueComponent);
+    const readonlyValue = this.getPluginSettingsProperty(propertyName);
+    const defaults = this.pluginSettingsComponent.defaultSettings;
+    const defaultValue = defaults[propertyName];
+    const defaultComponentValue = optionsExtension.pluginSettingsToComponentValueConverter(defaultValue);
+    textBasedComponent?.setPlaceholderValue(defaultComponentValue);
+    let validationMessage;
+    let tooltipEl = null;
+    let tooltipContentEl = null;
+    if (validatorEl) {
+      const wrapper = ensureWrapped(validatorEl);
+      tooltipEl = wrapper.createDiv();
+      addPluginCssClasses(tooltipEl, [CssClass.Tooltip, CssClass.TooltipValidator]);
+      tooltipContentEl = tooltipEl.createSpan();
+      const tooltipArrowEl = tooltipEl.createDiv();
+      addPluginCssClasses(tooltipArrowEl, CssClass.TooltipArrow);
+      tooltipEl.hide();
+      wrapper.append(tooltipEl);
+    }
+    registerAsyncEvent(
+      this.getRenderComponent(),
+      this.on("validationMessageChanged", (anotherPropertyName, anotherValidationMessage) => {
+        if (propertyName !== anotherPropertyName) {
+          return;
+        }
+        validationMessage = anotherValidationMessage;
+        updateValidatorElementDebounced();
+      })
+    );
+    let shouldEmptyOnBlur = false;
+    let shouldRevertToDefaultValueOnBlur = false;
+    if (textBasedComponent && optionsExtension.shouldShowPlaceholderForDefaultValues && isDeepEqual(readonlyValue, defaultValue)) {
+      textBasedComponent.empty();
+    } else {
+      valueComponent.setValue(optionsExtension.pluginSettingsToComponentValueConverter(readonlyValue));
+    }
+    let shouldSkipOnChange = false;
+    const UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS = 100;
+    const updateValidatorElementDebounced = debounce(() => {
+      window.requestAnimationFrame(() => {
+        updateValidatorEl();
+      });
+    }, UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS);
+    valueComponent.onChange(convertAsyncToSync(async (uiValue) => {
+      if (shouldSkipOnChange) {
+        shouldSkipOnChange = false;
+        return;
+      }
+      shouldEmptyOnBlur = false;
+      const oldValue = this.getPluginSettingsProperty(propertyName);
+      let newValue;
+      let shouldSetProperty = true;
+      shouldRevertToDefaultValueOnBlur = !!textBasedComponent?.isEmpty() && optionsExtension.shouldResetSettingWhenComponentIsEmpty;
+      if (shouldRevertToDefaultValueOnBlur) {
+        newValue = defaultValue;
+      } else {
+        const convertedValue = optionsExtension.componentToPluginSettingsValueConverter(uiValue);
+        if (isValidationMessageHolder(convertedValue)) {
+          validationMessage = convertedValue.validationMessage;
+          shouldSetProperty = false;
+        } else {
+          newValue = convertedValue;
+        }
+      }
+      if (shouldSetProperty) {
+        validationMessage = await this.pluginSettingsComponent.setProperty(propertyName, newValue);
+        if (textBasedComponent && optionsExtension.shouldShowPlaceholderForDefaultValues && !textBasedComponent.isEmpty() && isDeepEqual(newValue, defaultValue)) {
+          shouldEmptyOnBlur = true;
+        }
+      }
+      updateValidatorElementDebounced();
+      if (shouldSetProperty) {
+        await optionsExtension.onChanged(newValue, oldValue);
+      }
+      this.saveSettingsDebounced();
+    }));
+    validatorEl?.addEventListener("focus", () => {
+      updateValidatorElementDebounced();
+    });
+    validatorEl?.addEventListener("blur", () => {
+      updateValidatorElementDebounced();
+    });
+    validatorEl?.addEventListener("click", () => {
+      window.requestAnimationFrame(() => {
+        updateValidatorElementDebounced();
+      });
+    });
+    const validationMessages = this.pluginSettingsComponent.settingsState.validationMessages;
+    validationMessage = validationMessages[propertyName] ?? "";
+    updateValidatorElementDebounced();
+    return valueComponent;
+    function updateValidatorEl() {
+      if (!validatorEl?.isActiveElement()) {
+        if (shouldEmptyOnBlur) {
+          shouldEmptyOnBlur = false;
+          if (!textBasedComponent?.isEmpty()) {
+            shouldSkipOnChange = true;
+            textBasedComponent?.empty();
+          }
+        } else if (shouldRevertToDefaultValueOnBlur) {
+          shouldRevertToDefaultValueOnBlur = false;
+          if (textBasedComponent?.isEmpty()) {
+            shouldSkipOnChange = true;
+            valueComponent.setValue(defaultComponentValue);
+          }
+        }
+      }
+      if (!validatorEl) {
+        return;
+      }
+      assertNonNullable(tooltipContentEl);
+      if (validationMessage === "") {
+        validatorEl.setCustomValidity("");
+        validatorEl.checkValidity();
+        validationMessage = validatorEl.validationMessage;
+      }
+      validatorEl.setCustomValidity(validationMessage);
+      if (optionsExtension.shouldShowValidationMessage) {
+        tooltipContentEl.textContent = validationMessage;
+        tooltipEl?.toggle(!!validationMessage);
+      } else if (validationMessage) {
+        setTooltip(validatorEl, validationMessage);
+      }
+    }
+  }
+  /**
+   * Renders the plugin settings tab.
+   */
+  display() {
+    this.displayLegacy();
+  }
+  /**
+   * Legacy way to render the plugin settings tab imperatively.
+   *
+   * The pre-declarative fallback: Obsidian only calls it when {@link getSettingDefinitions} returns an empty
+   * array, i.e. when the consumer has not overridden {@link getSettingDefinitionItems}. Such a consumer
+   * overrides this method and builds the UI with {@link SettingEx} and {@link bind}.
+   */
+  displayLegacy() {
+    this.beginRenderCycle();
+    this.containerEl.empty();
+  }
+  /**
+   * Reads the value backing a native `control` setting definition.
+   *
+   * Obsidian calls it on every render of a `control`-type definition. The inherited implementation reads
+   * `plugin.settings`, which a plugin built on {@link PluginSettingsComponentBase} never populates, so it is
+   * routed to the settings component instead.
+   *
+   * @param key - The settings property name.
+   * @returns The current value.
+   */
+  getControlValue(key) {
+    return this.getPluginSettingsProperty(castTo(key));
+  }
+  /**
+   * Returns the declarative setting definitions rendered by Obsidian 1.13+.
+   *
+   * Delegates to {@link getSettingDefinitionItems}. When a consumer has not overridden that hook it returns
+   * an empty array, and Obsidian falls back to the imperative {@link displayLegacy} path.
+   *
+   * @returns The setting definitions.
+   */
+  getSettingDefinitions() {
+    return this.getSettingDefinitionItems();
+  }
+  /**
+   * Hides the plugin settings tab.
+   */
+  hide() {
+    super.hide();
+    this.saveSettingsDebounced.cancel();
+    this._isOpen = false;
+    this.endRenderCycle();
+    this.component.unload();
+    invokeAsyncSafely(() => this.hideAsync());
+  }
+  /**
+   * Async actions to perform when the settings tab is being hidden.
+   *
+   * @returns A {@link Promise} that resolves when the settings tab is hidden.
+   */
+  async hideAsync() {
+    await this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT);
+  }
+  /**
+   * Re-renders the settings tab after the underlying state changed.
+   *
+   * Rebuilds the definitions and re-renders, which covers both paths: Obsidian renders the declarative
+   * definitions when {@link getSettingDefinitionItems} provides them, and falls back to
+   * {@link displayLegacy} when it does not. Nothing is rendered while the tab is not the one on screen.
+   *
+   * Use it only for changes that alter the STRUCTURE of the tab — rows added or removed. When only a
+   * {@link PluginSettingsTabBaseSettingExParams.disabled} / {@link PluginSettingsTabBaseSettingExParams.visible}
+   * predicate has to be re-evaluated, call the much cheaper {@link refreshDomState} instead, which toggles the
+   * rendered DOM in place.
+   */
+  refresh() {
+    this.update();
+  }
+  /**
+   * Persists the value of a native `control` setting definition.
+   *
+   * The counterpart of {@link getControlValue}: it routes the write to the settings component instead of the
+   * inherited `plugin.saveData` path, so validation, transformers and the debounced save all apply as they do
+   * for a {@link bind}-ed component.
+   *
+   * @param key - The settings property name.
+   * @param value - The value to persist.
+   * @returns A {@link Promise} that resolves when the value is set.
+   */
+  async setControlValue(key, value) {
+    await this.pluginSettingsComponent.setProperty(castTo(key), castTo(value));
+    this.saveSettingsDebounced();
+  }
+  /**
+   * Shows the plugin settings tab.
+   */
+  show() {
+    this.app.setting.openTab(this);
+  }
+  /**
+   * The declarative setting definitions for the tab (Obsidian 1.13+).
+   *
+   * Consumers override this, typically building each row with {@link settingEx} and {@link bind} and grouping
+   * them with `settingGroupEx`. Returning an empty array — the default — makes Obsidian fall back to the
+   * imperative {@link displayLegacy} path.
+   *
+   * MUST be a pure builder. Obsidian calls it when the tab is registered (`addSettingTab`), long before the
+   * tab is ever opened, in order to index the settings for search. Anything with a side effect belongs inside
+   * a row's {@link PluginSettingsTabBaseSettingExParams.render} callback, which runs only when the row is
+   * actually rendered.
+   *
+   * @returns The setting definitions.
+   */
+  getSettingDefinitionItems() {
+    return [];
+  }
+  /**
+   * Called when the plugin settings are loaded.
+   *
+   * @param _loadedState - The loaded settings state.
+   * @param _isInitialLoad - Whether the settings are being loaded for the first time.
+   * @returns A {@link Promise} that resolves when the settings are loaded.
+   */
+  async onLoadSettings(_loadedState, _isInitialLoad) {
+    this.refresh();
+    await noopAsync();
+  }
+  /**
+   * Revalidates the settings.
+   *
+   * @returns A {@link Promise} that resolves when the settings are revalidated.
+   */
+  async revalidate() {
+    const validationMessages = await this.pluginSettingsComponent.revalidate();
+    await this.updateValidations(validationMessages);
+  }
+  /**
+   * Builds a search-indexable declarative row that is rendered imperatively.
+   *
+   * The bridge between the declarative API and this library's imperative building blocks: Obsidian owns the row (so it
+   * indexes it for search and evaluates its {@link PluginSettingsTabBaseSettingExParams.visible} /
+   * {@link PluginSettingsTabBaseSettingExParams.disabled} predicates on every
+   * {@link refreshDomState}), while {@link PluginSettingsTabBaseSettingExParams.render} fills it in with
+   * {@link SettingEx} adders and {@link bind} exactly as an imperative tab would.
+   *
+   * @param params - The row params.
+   * @returns The setting definition.
+   */
+  settingEx(params) {
+    return normalizeOptionalProperties({
+      aliases: params.aliases,
+      desc: params.desc,
+      disabled: params.disabled,
+      name: params.name,
+      render: (setting, group) => this.renderSettingEx({ group, setting, settingExParams: params }),
+      searchable: params.searchable,
+      visible: params.visible
+    });
+  }
+  /**
+   * Builds a declarative heading group.
+   *
+   * The declarative counterpart of `SettingGroupEx`: where that class appends a group to a container
+   * imperatively, this returns the definition Obsidian renders, so a group-structured tab keeps its shape
+   * after the migration.
+   *
+   * @param params - The group params.
+   * @returns The group definition.
+   */
+  settingGroupEx(params) {
+    return normalizeOptionalProperties({
+      ...params,
+      type: "group"
+    });
+  }
+  beginRenderCycle() {
+    this.endRenderCycle();
+    this.currentRenderComponent = this.createRenderComponent();
+  }
+  createRenderComponent() {
+    this._isOpen = true;
+    this.component.load();
+    return this.component.addChild(new ComponentEx());
+  }
+  endRenderCycle() {
+    const renderComponent = this.currentRenderComponent;
+    if (!renderComponent) {
+      return;
+    }
+    this.currentRenderComponent = null;
+    this.component.removeChild(renderComponent);
+  }
+  getPluginSettingsProperty(propertyName) {
+    const settings = this.pluginSettings;
+    return settings[propertyName];
+  }
+  getRenderComponent() {
+    this.currentRenderComponent ??= this.createRenderComponent();
+    return this.currentRenderComponent;
+  }
+  async onSaveSettings(params) {
+    const {
+      context,
+      newState,
+      oldState: _oldState
+    } = params;
+    if (context === SAVE_TO_FILE_CONTEXT) {
+      await this.updateValidations(newState.validationMessages);
+      return;
+    }
+    this.refresh();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Mirrors Obsidian's `SettingDefinitionRender.render`, whose cleanup function is optional.
+  renderSettingEx(params) {
+    const rowComponent = this.createRenderComponent();
+    const previousRenderComponent = this.currentRenderComponent;
+    this.currentRenderComponent = rowComponent;
+    try {
+      const cleanup = params.settingExParams.render(adoptSettingEx(params.setting), params.group);
+      return () => {
+        if (typeof cleanup === "function") {
+          cleanup();
+        }
+        this.component.removeChild(rowComponent);
+      };
+    } finally {
+      this.currentRenderComponent = previousRenderComponent;
+    }
+  }
+  async updateValidations(validationMessages) {
+    for (const [propertyName, validationMessage] of Object.entries(validationMessages)) {
+      await this.triggerAsync("validationMessageChanged", propertyName, validationMessage);
+    }
+  }
+}
+export {
+  PluginSettingsTabBase,
+  SAVE_TO_FILE_CONTEXT
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/plugin/plugin-settings-tab.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines a base class for creating plugin setting tabs in Obsidian.\n * It provides a utility method to bind value components to plugin settings and handle changes.\n */\n\nimport type { StringKeys } from '@mnaoumov/typescript-lib/type';\nimport type {\n  Debouncer,\n  Plugin,\n  Setting,\n  SettingDefinitionGroup,\n  SettingDefinitionItem,\n  SettingDefinitionRender,\n  SettingGroup\n} from 'obsidian';\nimport type {\n  ConditionalKeys,\n  Except,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '@mnaoumov/typescript-lib/async';\nimport { mixinAsyncEvents } from '@mnaoumov/typescript-lib/async-events';\nimport {\n  noop,\n  noopAsync\n} from '@mnaoumov/typescript-lib/function';\nimport {\n  castTo,\n  isDeepEqual,\n  normalizeOptionalProperties\n} from '@mnaoumov/typescript-lib/object-utils';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport {\n  debounce,\n  PluginSettingTab,\n  setTooltip\n} from 'obsidian';\n\nimport type {\n  PluginSettingsComponentBase,\n  ReadonlyPluginSettings,\n  ReadonlyPluginSettingsState\n} from '../components/plugin-settings-component.ts';\nimport type { ValueComponentWithChangeTracking } from '../setting-components/value-component-with-change-tracking.ts';\nimport type { SettingEx } from '../setting-ex.ts';\nimport type { ValidationMessageHolder } from '../validation.ts';\n\nimport { registerAsyncEvent } from '../components/async-events-component.ts';\nimport { ComponentEx } from '../components/component-ex.ts';\nimport { CssClass } from '../css-class.ts';\nimport { ensureWrapped } from '../setting-components/setting-component-wrapper.ts';\nimport { getTextBasedComponentValue } from '../setting-components/text-based-component.ts';\nimport { getValidatorComponent } from '../setting-components/validator-component.ts';\nimport { adoptSettingEx } from '../setting-ex.ts';\nimport { isValidationMessageHolder } from '../validation.ts';\nimport { addPluginCssClasses } from './plugin-context.ts';\n\n/**\n * A context passed to the {@link PluginSettingsComponentBase.saveToFile} method.\n */\nexport const SAVE_TO_FILE_CONTEXT = 'PluginSettingsTab';\n\n/**\n * Options for `PluginSettingsTabBase.bind`.\n *\n * @typeParam T - The type of the settings property value.\n */\nexport interface BindOptions<T> {\n  /**\n   * A callback function that is called when the value of the component changes.\n   */\n  readonly onChanged?: (newValue: ReadonlyDeep<T>, oldValue: ReadonlyDeep<T>) => Promisable<void>;\n\n  /**\n   * Whether to reset the setting when the component value is empty.\n   * Applicable only to text-based components.\n   *\n   * @default `true`\n   */\n  readonly shouldResetSettingWhenComponentIsEmpty?: boolean;\n\n  /**\n   * Whether to show the placeholder for default values.\n   * Applicable only to text-based components.\n   *\n   * @default `true`\n   */\n  readonly shouldShowPlaceholderForDefaultValues?: boolean;\n\n  /**\n   * Whether to show the validation message when the component value is invalid.\n   *\n   * @default `true`\n   */\n  readonly shouldShowValidationMessage?: boolean;\n}\n\n/**\n * Extended options for `PluginSettingsTabBase.bind`.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam PropertyName - The settings property name being bound.\n */\nexport interface BindOptionsExtended<\n  PluginSettings extends object,\n  UIValue,\n  PropertyName extends StringKeys<PluginSettings>\n> extends BindOptions<PluginSettings[PropertyName]> {\n  /**\n   * Converts the UI component's value back to the plugin settings value.\n   *\n   * @param uiValue - The value of the UI component.\n   * @returns The value to set on the plugin settings.\n   */\n  componentToPluginSettingsValueConverter: (uiValue: UIValue) => PluginSettings[PropertyName] | ValidationMessageHolder;\n\n  /**\n   * Converts the plugin settings value to the value used by the UI component.\n   *\n   * @param pluginSettingsValue - The value of the property in the plugin settings.\n   * @returns The value to set on the UI component.\n   */\n  pluginSettingsToComponentValueConverter: (pluginSettingsValue: ReadonlyDeep<PluginSettings[PropertyName]>) => UIValue;\n}\n\n/**\n * Extended params for {@link PluginSettingsTabBase.bind} with value converters.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam TValueComponent - The type of the value component.\n * @typeParam PropertyName - The settings property name being bound.\n */\nexport interface PluginSettingsTabBaseBindExtendedParams<\n  PluginSettings extends object,\n  UIValue,\n  TValueComponent,\n  PropertyName extends StringKeys<PluginSettings>\n> extends BindOptionsExtended<PluginSettings, UIValue, PropertyName> {\n  /**\n   * The property name of the plugin settings to bind to.\n   */\n  readonly propertyName: PropertyName;\n\n  /**\n   * The value component to bind.\n   */\n  readonly valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>;\n}\n\n/**\n * Params for {@link PluginSettingsTabBase.bind}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam TValueComponent - The type of the value component.\n */\nexport interface PluginSettingsTabBaseBindParams<\n  PluginSettings extends object,\n  UIValue,\n  TValueComponent\n> extends BindOptions<UIValue> {\n  /**\n   * The property of the plugin settings to bind to.\n   */\n  readonly propertyName: ConditionalKeys<PluginSettings, UIValue>;\n\n  /**\n   * The value component to bind.\n   */\n  readonly valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>;\n}\n\n/**\n * Params for creating a {@link PluginSettingsTabBase}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\nexport interface PluginSettingsTabBaseConstructorParams<PluginSettings extends object> {\n  /**\n   * The plugin instance (needed by Obsidian's PluginSettingTab).\n   */\n  readonly plugin: Plugin;\n\n  /**\n   * The settings component.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<PluginSettings>;\n}\n\n/**\n * Params for {@link PluginSettingsTabBase.settingEx}.\n */\nexport interface PluginSettingsTabBaseSettingExParams {\n  /**\n   * Additional search terms for the setting.\n   */\n  readonly aliases?: string[];\n\n  /**\n   * The description of the setting. Used for rendering; the text content of a fragment is used for search.\n   */\n  readonly desc?: DocumentFragment | string;\n\n  /**\n   * Whether the setting row is disabled.\n   *\n   * A function form is re-evaluated on every render AND on every {@link PluginSettingsTabBase.refreshDomState}\n   * call, so it can reflect runtime state. Obsidian applies it with `Setting.setDisabled`, which disables the\n   * row and every component registered on it.\n   */\n  readonly disabled?: (() => boolean) | boolean;\n\n  /**\n   * The display name of the setting. Used for rendering and search.\n   */\n  readonly name: string;\n\n  /**\n   * Renders the setting row imperatively, typically via the {@link SettingEx} adders and\n   * {@link PluginSettingsTabBase.bind}.\n   *\n   * The setting Obsidian creates for the row is adopted into a {@link SettingEx} before it is handed over, so\n   * an imperative row body carries over unchanged. May return a cleanup function, invoked before the row is\n   * torn down or re-rendered.\n   *\n   * @param setting - The setting to render into.\n   * @param group - The group the setting belongs to.\n   * @returns An optional cleanup function.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Mirrors Obsidian's `SettingDefinitionRender.render`, whose cleanup function is optional.\n  readonly render: (setting: SettingEx, group: SettingGroup) => (() => void) | void;\n\n  /**\n   * Controls whether the setting is included in the settings search. Defaults to `true`.\n   */\n  readonly searchable?: (() => boolean) | boolean;\n\n  /**\n   * Controls whether the setting row is rendered. A function form is re-evaluated on every render and on\n   * every {@link PluginSettingsTabBase.refreshDomState} call. Defaults to `true`.\n   */\n  readonly visible?: (() => boolean) | boolean;\n}\n\n/**\n * Params for {@link PluginSettingsTabBase.settingGroupEx}.\n *\n * Every member of {@link SettingDefinitionGroup} except its discriminator, which\n * {@link PluginSettingsTabBase.settingGroupEx} sets.\n */\nexport type PluginSettingsTabBaseSettingGroupExParams = Except<SettingDefinitionGroup, 'type'>;\n\n/**\n * Implementation params for {@link PluginSettingsTabBase.bind}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam TValueComponent - The type of the value component.\n * @typeParam PropertyName - The settings property name being bound.\n */\ninterface PluginSettingsTabBaseBindImplParams<\n  PluginSettings extends object,\n  UIValue,\n  TValueComponent,\n  PropertyName extends StringKeys<PluginSettings>\n> extends BindOptions<PluginSettings[PropertyName]> {\n  /**\n   * The property name of the plugin settings to bind to.\n   */\n  readonly propertyName: PropertyName;\n\n  /**\n   * The value component to bind.\n   */\n  readonly valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>;\n}\n\ninterface PluginSettingsTabBaseEventMap {\n  validationMessageChanged: [propertyName: string, validationMessage: string];\n}\n\n/**\n * Parameters for {@link PluginSettingsTabBase.onSaveSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\ninterface PluginSettingsTabBaseOnSaveSettingsParams<PluginSettings extends object> {\n  /**\n   * The save context.\n   */\n  readonly context: unknown;\n\n  /**\n   * The new settings state.\n   */\n  readonly newState: ReadonlyPluginSettingsState<PluginSettings>;\n\n  /**\n   * The old settings state.\n   */\n  readonly oldState: ReadonlyPluginSettingsState<PluginSettings>;\n}\n\n/**\n * Params for {@link PluginSettingsTabBase.renderSettingEx}.\n */\ninterface PluginSettingsTabBaseRenderSettingExParams {\n  /**\n   * The group the row belongs to.\n   */\n  readonly group: SettingGroup;\n\n  /**\n   * The setting Obsidian created for the row.\n   */\n  readonly setting: Setting;\n\n  /**\n   * The params the row was declared with.\n   */\n  readonly settingExParams: PluginSettingsTabBaseSettingExParams;\n}\n\n/**\n * Constructor params for {@link PluginSettingsTabEventsComponent}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\ninterface PluginSettingsTabEventsComponentConstructorParams<PluginSettings extends object> {\n  /**\n   * Called when the plugin settings are loaded.\n   */\n  readonly onLoadSettings: (loadedState: ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad: boolean) => Promisable<void>;\n\n  /**\n   * Called when the plugin settings are saved.\n   */\n  readonly onSaveSettings: (\n    newState: ReadonlyPluginSettingsState<PluginSettings>,\n    oldState: ReadonlyPluginSettingsState<PluginSettings>,\n    context: unknown\n  ) => Promisable<void>;\n\n  /**\n   * The settings component to subscribe to.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<PluginSettings>;\n}\n\n/**\n * Owns the tab's subscriptions to the settings component.\n *\n * The subscriptions live in {@link onload} rather than at each render, so that a load/unload pair registers\n * them exactly once. Registering them per render instead would accumulate a fresh pair on every render cycle,\n * because {@link ComponentEx.load} early-returns once the component is loaded and nothing resets in between.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\nclass PluginSettingsTabEventsComponent<PluginSettings extends object> extends ComponentEx {\n  private readonly params: PluginSettingsTabEventsComponentConstructorParams<PluginSettings>;\n\n  /**\n   * Creates a new component.\n   *\n   * @param params - The params.\n   */\n  public constructor(params: PluginSettingsTabEventsComponentConstructorParams<PluginSettings>) {\n    super();\n    this.params = params;\n  }\n\n  /**\n   * Subscribes to the settings component's events.\n   */\n  public override onload(): void {\n    super.onload();\n    const { pluginSettingsComponent } = this.params;\n    registerAsyncEvent(this, pluginSettingsComponent.on('loadSettings', (loadedState, isInitialLoad) => this.params.onLoadSettings(loadedState, isInitialLoad)));\n    registerAsyncEvent(this, pluginSettingsComponent.on('saveSettings', (newState, oldState, context) => this.params.onSaveSettings(newState, oldState, context)));\n  }\n}\n\n/**\n * Base class for creating plugin settings tabs in Obsidian.\n * Provides a method for binding value components to plugin settings and handling changes.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\nexport abstract class PluginSettingsTabBase<PluginSettings extends object> extends mixinAsyncEvents<PluginSettingsTabBaseEventMap>()(PluginSettingTab) {\n  /**\n   * Whether the plugin settings tab is open.\n   *\n   * @returns Whether the plugin settings tab is open.\n   */\n  public get isOpen(): boolean {\n    return this._isOpen;\n  }\n\n  /**\n   * The settings manager.\n   */\n  protected readonly pluginSettingsComponent: PluginSettingsComponentBase<PluginSettings>;\n\n  /**\n   * A debounce timeout for saving settings.\n   *\n   * @returns The debounce timeout for saving settings.\n   */\n  protected get saveSettingsDebounceTimeoutInMilliseconds(): number {\n    const DEFAULT = 2000;\n    return DEFAULT;\n  }\n\n  private _isOpen = false;\n  private readonly component: PluginSettingsTabEventsComponent<PluginSettings>;\n  private currentRenderComponent: ComponentEx | null = null;\n  private readonly saveSettingsDebounced: Debouncer<[], void>;\n\n  private get pluginSettings(): ReadonlyPluginSettings<PluginSettings> {\n    return this.pluginSettingsComponent.settingsState.inputValues;\n  }\n\n  /**\n   * Creates a new plugin settings tab.\n   *\n   * @param params - The params.\n   */\n  public constructor(params: PluginSettingsTabBaseConstructorParams<PluginSettings>) {\n    super(params.plugin.app, params.plugin);\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    addPluginCssClasses(this.containerEl, CssClass.PluginSettingsTab);\n    this.saveSettingsDebounced = debounce(\n      convertAsyncToSync(() => this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT)),\n      this.saveSettingsDebounceTimeoutInMilliseconds\n    );\n    this.component = new PluginSettingsTabEventsComponent<PluginSettings>({\n      onLoadSettings: (loadedState, isInitialLoad): Promisable<void> => this.onLoadSettings(loadedState, isInitialLoad),\n      onSaveSettings: (newState, oldState, context): Promisable<void> => this.onSaveSettings({ context, newState, oldState }),\n      pluginSettingsComponent: this.pluginSettingsComponent\n    });\n  }\n\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @param params - The params for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent\n  >(\n    params: PluginSettingsTabBaseBindParams<PluginSettings, UIValue, TValueComponent>\n  ): TValueComponent;\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @typeParam PropertyName - The property name of the plugin settings to bind to.\n   * @param params - The params for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    PropertyName extends StringKeys<PluginSettings>\n  >(\n    params: PluginSettingsTabBaseBindExtendedParams<PluginSettings, UIValue, TValueComponent, PropertyName>\n  ): TValueComponent;\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @typeParam PropertyName - The property name of the plugin settings to bind to.\n   * @param params - The params for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    PropertyName extends StringKeys<PluginSettings>\n  >(\n    params: PluginSettingsTabBaseBindImplParams<PluginSettings, UIValue, TValueComponent, PropertyName> // eslint-disable-line obsidian-dev-utils/params-options-name-match -- bind overload shares the Bind* param family.\n  ): TValueComponent {\n    const {\n      propertyName,\n      valueComponent,\n      ...options\n    } = params;\n    type PropertyType = PluginSettings[PropertyName];\n    const DEFAULT_OPTIONS: Required<BindOptionsExtended<PluginSettings, UIValue, PropertyName>> = {\n      componentToPluginSettingsValueConverter: (value: UIValue): PropertyType => value as PropertyType,\n      onChanged: noop,\n      pluginSettingsToComponentValueConverter: (value: ReadonlyDeep<PropertyType>): UIValue => value as UIValue,\n      shouldResetSettingWhenComponentIsEmpty: true,\n      shouldShowPlaceholderForDefaultValues: true,\n      shouldShowValidationMessage: true\n    };\n\n    const optionsExtension: Required<BindOptionsExtended<PluginSettings, UIValue, PropertyName>> = { ...DEFAULT_OPTIONS, ...options };\n\n    const validatorEl = getValidatorComponent(valueComponent)?.validatorEl;\n\n    const textBasedComponent = getTextBasedComponentValue(valueComponent);\n\n    const readonlyValue = this.getPluginSettingsProperty(propertyName);\n    const defaults = this.pluginSettingsComponent.defaultSettings as PluginSettings;\n    const defaultValue = defaults[propertyName];\n    const defaultComponentValue = optionsExtension.pluginSettingsToComponentValueConverter(defaultValue as ReadonlyDeep<PropertyType>);\n    textBasedComponent?.setPlaceholderValue(defaultComponentValue);\n\n    let validationMessage: string;\n    let tooltipEl: HTMLElement | null = null;\n    let tooltipContentEl: HTMLElement | null = null;\n    if (validatorEl) {\n      const wrapper = ensureWrapped(validatorEl);\n      tooltipEl = wrapper.createDiv();\n      addPluginCssClasses(tooltipEl, [CssClass.Tooltip, CssClass.TooltipValidator]);\n      tooltipContentEl = tooltipEl.createSpan();\n      const tooltipArrowEl = tooltipEl.createDiv();\n      addPluginCssClasses(tooltipArrowEl, CssClass.TooltipArrow);\n      tooltipEl.hide();\n      wrapper.append(tooltipEl);\n    }\n\n    registerAsyncEvent(\n      this.getRenderComponent(),\n      this.on('validationMessageChanged', (anotherPropertyName, anotherValidationMessage) => {\n        if (propertyName !== anotherPropertyName) {\n          return;\n        }\n\n        validationMessage = anotherValidationMessage;\n        updateValidatorElementDebounced();\n      })\n    );\n\n    let shouldEmptyOnBlur = false;\n    let shouldRevertToDefaultValueOnBlur = false;\n\n    if (textBasedComponent && optionsExtension.shouldShowPlaceholderForDefaultValues && isDeepEqual(readonlyValue, defaultValue)) {\n      textBasedComponent.empty();\n    } else {\n      valueComponent.setValue(optionsExtension.pluginSettingsToComponentValueConverter(readonlyValue));\n    }\n\n    let shouldSkipOnChange = false;\n    const UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS = 100;\n    const updateValidatorElementDebounced = debounce(() => {\n      window.requestAnimationFrame(() => {\n        updateValidatorEl();\n      });\n    }, UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS);\n\n    valueComponent.onChange(convertAsyncToSync(async (uiValue) => {\n      if (shouldSkipOnChange) {\n        shouldSkipOnChange = false;\n        return;\n      }\n\n      shouldEmptyOnBlur = false;\n\n      const oldValue = this.getPluginSettingsProperty(propertyName);\n      let newValue: PropertyType | undefined;\n      let shouldSetProperty = true;\n      shouldRevertToDefaultValueOnBlur = !!textBasedComponent?.isEmpty() && optionsExtension.shouldResetSettingWhenComponentIsEmpty;\n      if (shouldRevertToDefaultValueOnBlur) {\n        newValue = defaultValue;\n      } else {\n        const convertedValue = optionsExtension.componentToPluginSettingsValueConverter(uiValue);\n        if (isValidationMessageHolder(convertedValue)) {\n          validationMessage = convertedValue.validationMessage;\n          shouldSetProperty = false;\n        } else {\n          newValue = convertedValue;\n        }\n      }\n\n      if (shouldSetProperty) {\n        validationMessage = await this.pluginSettingsComponent.setProperty(propertyName, newValue as PluginSettings[PropertyName]);\n        if (textBasedComponent && optionsExtension.shouldShowPlaceholderForDefaultValues && !textBasedComponent.isEmpty() && isDeepEqual(newValue, defaultValue)) {\n          shouldEmptyOnBlur = true;\n        }\n      }\n\n      updateValidatorElementDebounced();\n      if (shouldSetProperty) {\n        await optionsExtension.onChanged(newValue as ReadonlyDeep<PropertyType>, oldValue);\n      }\n      this.saveSettingsDebounced();\n    }));\n\n    validatorEl?.addEventListener('focus', () => {\n      updateValidatorElementDebounced();\n    });\n    validatorEl?.addEventListener('blur', () => {\n      updateValidatorElementDebounced();\n    });\n    validatorEl?.addEventListener('click', () => {\n      window.requestAnimationFrame(() => {\n        updateValidatorElementDebounced();\n      });\n    });\n\n    const validationMessages = this.pluginSettingsComponent.settingsState.validationMessages as Record<string, string>;\n    validationMessage = validationMessages[propertyName] ?? '';\n    updateValidatorElementDebounced();\n\n    return valueComponent;\n\n    function updateValidatorEl(): void {\n      if (!validatorEl?.isActiveElement()) {\n        if (shouldEmptyOnBlur) {\n          shouldEmptyOnBlur = false;\n\n          if (!textBasedComponent?.isEmpty()) {\n            shouldSkipOnChange = true;\n            textBasedComponent?.empty();\n          }\n        } else if (shouldRevertToDefaultValueOnBlur) {\n          shouldRevertToDefaultValueOnBlur = false;\n\n          if (textBasedComponent?.isEmpty()) {\n            shouldSkipOnChange = true;\n            valueComponent.setValue(defaultComponentValue);\n          }\n        }\n      }\n\n      if (!validatorEl) {\n        return;\n      }\n\n      assertNonNullable(tooltipContentEl);\n\n      if (validationMessage === '') {\n        validatorEl.setCustomValidity('');\n        validatorEl.checkValidity();\n        validationMessage = validatorEl.validationMessage;\n      }\n\n      validatorEl.setCustomValidity(validationMessage);\n      if (optionsExtension.shouldShowValidationMessage) {\n        tooltipContentEl.textContent = validationMessage;\n        tooltipEl?.toggle(!!validationMessage);\n      } else if (validationMessage) {\n        setTooltip(validatorEl, validationMessage);\n      }\n    }\n  }\n\n  /**\n   * Renders the plugin settings tab.\n   */\n  public override display(): void {\n    this.displayLegacy();\n  }\n\n  /**\n   * Legacy way to render the plugin settings tab imperatively.\n   *\n   * The pre-declarative fallback: Obsidian only calls it when {@link getSettingDefinitions} returns an empty\n   * array, i.e. when the consumer has not overridden {@link getSettingDefinitionItems}. Such a consumer\n   * overrides this method and builds the UI with {@link SettingEx} and {@link bind}.\n   */\n  public displayLegacy(): void {\n    this.beginRenderCycle();\n    this.containerEl.empty();\n  }\n\n  /**\n   * Reads the value backing a native `control` setting definition.\n   *\n   * Obsidian calls it on every render of a `control`-type definition. The inherited implementation reads\n   * `plugin.settings`, which a plugin built on {@link PluginSettingsComponentBase} never populates, so it is\n   * routed to the settings component instead.\n   *\n   * @param key - The settings property name.\n   * @returns The current value.\n   */\n  public override getControlValue(key: string): unknown {\n    return this.getPluginSettingsProperty(castTo<StringKeys<PluginSettings>>(key));\n  }\n\n  /**\n   * Returns the declarative setting definitions rendered by Obsidian 1.13+.\n   *\n   * Delegates to {@link getSettingDefinitionItems}. When a consumer has not overridden that hook it returns\n   * an empty array, and Obsidian falls back to the imperative {@link displayLegacy} path.\n   *\n   * @returns The setting definitions.\n   */\n  public override getSettingDefinitions(): SettingDefinitionItem[] {\n    return this.getSettingDefinitionItems();\n  }\n\n  /**\n   * Hides the plugin settings tab.\n   */\n  public override hide(): void {\n    super.hide();\n    this.saveSettingsDebounced.cancel();\n    this._isOpen = false;\n    this.endRenderCycle();\n    this.component.unload();\n    invokeAsyncSafely(() => this.hideAsync());\n  }\n\n  /**\n   * Async actions to perform when the settings tab is being hidden.\n   *\n   * @returns A {@link Promise} that resolves when the settings tab is hidden.\n   */\n  public async hideAsync(): Promise<void> {\n    await this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT);\n  }\n\n  /**\n   * Re-renders the settings tab after the underlying state changed.\n   *\n   * Rebuilds the definitions and re-renders, which covers both paths: Obsidian renders the declarative\n   * definitions when {@link getSettingDefinitionItems} provides them, and falls back to\n   * {@link displayLegacy} when it does not. Nothing is rendered while the tab is not the one on screen.\n   *\n   * Use it only for changes that alter the STRUCTURE of the tab \u2014 rows added or removed. When only a\n   * {@link PluginSettingsTabBaseSettingExParams.disabled} / {@link PluginSettingsTabBaseSettingExParams.visible}\n   * predicate has to be re-evaluated, call the much cheaper {@link refreshDomState} instead, which toggles the\n   * rendered DOM in place.\n   */\n  public refresh(): void {\n    this.update();\n  }\n\n  /**\n   * Persists the value of a native `control` setting definition.\n   *\n   * The counterpart of {@link getControlValue}: it routes the write to the settings component instead of the\n   * inherited `plugin.saveData` path, so validation, transformers and the debounced save all apply as they do\n   * for a {@link bind}-ed component.\n   *\n   * @param key - The settings property name.\n   * @param value - The value to persist.\n   * @returns A {@link Promise} that resolves when the value is set.\n   */\n  public override async setControlValue(key: string, value: unknown): Promise<void> {\n    type PropertyName = StringKeys<PluginSettings>;\n    await this.pluginSettingsComponent.setProperty(castTo<PropertyName>(key), castTo<PluginSettings[PropertyName]>(value));\n    this.saveSettingsDebounced();\n  }\n\n  /**\n   * Shows the plugin settings tab.\n   */\n  public show(): void {\n    this.app.setting.openTab(this);\n  }\n\n  /**\n   * The declarative setting definitions for the tab (Obsidian 1.13+).\n   *\n   * Consumers override this, typically building each row with {@link settingEx} and {@link bind} and grouping\n   * them with `settingGroupEx`. Returning an empty array \u2014 the default \u2014 makes Obsidian fall back to the\n   * imperative {@link displayLegacy} path.\n   *\n   * MUST be a pure builder. Obsidian calls it when the tab is registered (`addSettingTab`), long before the\n   * tab is ever opened, in order to index the settings for search. Anything with a side effect belongs inside\n   * a row's {@link PluginSettingsTabBaseSettingExParams.render} callback, which runs only when the row is\n   * actually rendered.\n   *\n   * @returns The setting definitions.\n   */\n  protected getSettingDefinitionItems(): SettingDefinitionItem[] {\n    return [];\n  }\n\n  /**\n   * Called when the plugin settings are loaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether the settings are being loaded for the first time.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  protected async onLoadSettings(_loadedState: ReadonlyPluginSettingsState<PluginSettings>, _isInitialLoad: boolean): Promise<void> {\n    this.refresh();\n    await noopAsync();\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns A {@link Promise} that resolves when the settings are revalidated.\n   */\n  protected async revalidate(): Promise<void> {\n    const validationMessages = await this.pluginSettingsComponent.revalidate();\n    await this.updateValidations(validationMessages);\n  }\n\n  /**\n   * Builds a search-indexable declarative row that is rendered imperatively.\n   *\n   * The bridge between the declarative API and this library's imperative building blocks: Obsidian owns the row (so it\n   * indexes it for search and evaluates its {@link PluginSettingsTabBaseSettingExParams.visible} /\n   * {@link PluginSettingsTabBaseSettingExParams.disabled} predicates on every\n   * {@link refreshDomState}), while {@link PluginSettingsTabBaseSettingExParams.render} fills it in with\n   * {@link SettingEx} adders and {@link bind} exactly as an imperative tab would.\n   *\n   * @param params - The row params.\n   * @returns The setting definition.\n   */\n  protected settingEx(params: PluginSettingsTabBaseSettingExParams): SettingDefinitionRender {\n    return normalizeOptionalProperties<SettingDefinitionRender>({\n      aliases: params.aliases,\n      desc: params.desc,\n      disabled: params.disabled,\n      name: params.name,\n      render: (setting: Setting, group: SettingGroup) => this.renderSettingEx({ group, setting, settingExParams: params }),\n      searchable: params.searchable,\n      visible: params.visible\n    });\n  }\n\n  /**\n   * Builds a declarative heading group.\n   *\n   * The declarative counterpart of `SettingGroupEx`: where that class appends a group to a container\n   * imperatively, this returns the definition Obsidian renders, so a group-structured tab keeps its shape\n   * after the migration.\n   *\n   * @param params - The group params.\n   * @returns The group definition.\n   */\n  protected settingGroupEx(params: PluginSettingsTabBaseSettingGroupExParams): SettingDefinitionGroup {\n    return normalizeOptionalProperties<SettingDefinitionGroup>({\n      ...params,\n      type: 'group'\n    });\n  }\n\n  private beginRenderCycle(): void {\n    this.endRenderCycle();\n    this.currentRenderComponent = this.createRenderComponent();\n  }\n\n  private createRenderComponent(): ComponentEx {\n    this._isOpen = true;\n    this.component.load();\n    return this.component.addChild(new ComponentEx());\n  }\n\n  private endRenderCycle(): void {\n    const renderComponent = this.currentRenderComponent;\n    if (!renderComponent) {\n      return;\n    }\n\n    this.currentRenderComponent = null;\n    this.component.removeChild(renderComponent);\n  }\n\n  private getPluginSettingsProperty<PropertyName extends StringKeys<PluginSettings>>(\n    propertyName: PropertyName\n  ): ReadonlyDeep<PluginSettings[PropertyName]> {\n    const settings = this.pluginSettings as PluginSettings;\n    return settings[propertyName] as ReadonlyDeep<PluginSettings[PropertyName]>;\n  }\n\n  private getRenderComponent(): ComponentEx {\n    this.currentRenderComponent ??= this.createRenderComponent();\n    return this.currentRenderComponent;\n  }\n\n  private async onSaveSettings(params: PluginSettingsTabBaseOnSaveSettingsParams<PluginSettings>): Promise<void> {\n    const {\n      context,\n      newState,\n      oldState: _oldState\n    } = params;\n    if (context === SAVE_TO_FILE_CONTEXT) {\n      await this.updateValidations(newState.validationMessages as Record<StringKeys<PluginSettings>, string>);\n      return;\n    }\n\n    this.refresh();\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Mirrors Obsidian's `SettingDefinitionRender.render`, whose cleanup function is optional.\n  private renderSettingEx(params: PluginSettingsTabBaseRenderSettingExParams): (() => void) | void {\n    const rowComponent = this.createRenderComponent();\n    const previousRenderComponent = this.currentRenderComponent;\n    this.currentRenderComponent = rowComponent;\n\n    try {\n      const cleanup = params.settingExParams.render(adoptSettingEx(params.setting), params.group);\n      return () => {\n        if (typeof cleanup === 'function') {\n          cleanup();\n        }\n\n        this.component.removeChild(rowComponent);\n      };\n    } finally {\n      this.currentRenderComponent = previousRenderComponent;\n    }\n  }\n\n  private async updateValidations(validationMessages: Record<StringKeys<PluginSettings>, string>): Promise<void> {\n    for (const [propertyName, validationMessage] of Object.entries(validationMessages)) {\n      await this.triggerAsync('validationMessageChanged', propertyName, validationMessage as string);\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": []
}
