obsidian-dev-utils 88.5.0 → 88.7.0

package/dist/lib/cjs/obsidian/plugin/plugin-settings-tab.cjs

@@ -141,9 +141,31 @@ var import_css_class = require('../css-class.cjs');
 var import_setting_component_wrapper = require('../setting-components/setting-component-wrapper.cjs');
 var import_text_based_component = require('../setting-components/text-based-component.cjs');
 var import_validator_component = require('../setting-components/validator-component.cjs');
+var import_setting_ex = require('../setting-ex.cjs');
 var import_validation = require('../validation.cjs');
 var import_plugin_context = require('./plugin-context.cjs');
 const SAVE_TO_FILE_CONTEXT = "PluginSettingsTab";
+class PluginSettingsTabEventsComponent extends import_component_ex.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;
+    (0, import_async_events_component.registerAsyncEvent)(this, pluginSettingsComponent.on("loadSettings", (loadedState, isInitialLoad) => this.params.onLoadSettings(loadedState, isInitialLoad)));
+    (0, import_async_events_component.registerAsyncEvent)(this, pluginSettingsComponent.on("saveSettings", (newState, oldState, context) => this.params.onSaveSettings(newState, oldState, context)));
+  }
+}
 class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(import_obsidian.PluginSettingTab) {
   /**
    * Whether the plugin settings tab is open.
@@ -168,6 +190,7 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
   }
   _isOpen = false;
   component;
+  currentRenderComponent = null;
   saveSettingsDebounced;
   get pluginSettings() {
     return this.pluginSettingsComponent.settingsState.inputValues;
@@ -185,7 +208,11 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
       (0, import_async.convertAsyncToSync)(() => this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT)),
       this.saveSettingsDebounceTimeoutInMilliseconds
     );
-    this.component = new import_component_ex.ComponentEx();
+    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.
@@ -232,7 +259,7 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
       wrapper.appendChild(tooltipEl);
     }
     (0, import_async_events_component.registerAsyncEvent)(
-      this.component,
+      this.getRenderComponent(),
       this.on("validationMessageChanged", (anotherPropertyName, anotherValidationMessage) => {
         if (propertyName !== anotherPropertyName) {
           return;
@@ -344,16 +371,39 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
     this.displayLegacy();
   }
   /**
-   * Legacy way to render the plugin settings tab.
+   * Legacy way to render the plugin settings tab imperatively.
    *
-   * Temporary workaround to avoid dealing with `@deprecated`.
+   * 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();
-    this._isOpen = true;
-    this.component.load();
-    (0, import_async_events_component.registerAsyncEvent)(this.component, this.pluginSettingsComponent.on("loadSettings", this.onLoadSettings.bind(this)));
-    (0, import_async_events_component.registerAsyncEvent)(this.component, this.pluginSettingsComponent.on("saveSettings", (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));
+  }
+  /**
+   * 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((0, import_object_utils.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.
@@ -362,6 +412,7 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
     super.hide();
     this.saveSettingsDebounced.cancel();
     this._isOpen = false;
+    this.endRenderCycle();
     this.component.unload();
     (0, import_async.invokeAsyncSafely)(() => this.hideAsync());
   }
@@ -373,12 +424,59 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
   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((0, import_object_utils.castTo)(key), (0, import_object_utils.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.
    *
@@ -387,7 +485,7 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
    * @returns A {@link Promise} that resolves when the settings are loaded.
    */
   async onLoadSettings(_loadedState, _isInitialLoad) {
-    this.displayLegacy();
+    this.refresh();
     await (0, import_function.noopAsync)();
   }
   /**
@@ -399,10 +497,70 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
     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 ODU'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 (0, import_object_utils.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 (0, import_object_utils.normalizeOptionalProperties)({
+      ...params,
+      type: "group"
+    });
+  }
+  beginRenderCycle() {
+    this.endRenderCycle();
+    this.currentRenderComponent = this.createRenderComponent();
+  }
+  createRenderComponent() {
+    this._isOpen = true;
+    this.component.load();
+    return this.component.addChild(new import_component_ex.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,
@@ -413,7 +571,24 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
       await this.updateValidations(newState.validationMessages);
       return;
     }
-    this.displayLegacy();
+    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((0, import_setting_ex.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)) {
@@ -426,4 +601,4 @@ class PluginSettingsTabBase extends (0, import_async_events.mixinAsyncEvents)()(
   PluginSettingsTabBase,
   SAVE_TO_FILE_CONTEXT
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/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 {\n  Debouncer,\n  Plugin\n} from 'obsidian';\nimport type {\n  ConditionalKeys,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport {\n  debounce,\n  PluginSettingTab,\n  setTooltip\n} from 'obsidian';\n\nimport type { StringKeys } from '../../type.ts';\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 { ValidationMessageHolder } from '../validation.ts';\n\nimport { mixinAsyncEvents } from '../../async-events.ts';\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../async.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport { deepEqual } from '../../object-utils.ts';\nimport { assertNonNullable } from '../../type-guards.ts';\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 { 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  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 * 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 * 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 = 2_000;\n    return DEFAULT;\n  }\n\n  private _isOpen = false;\n  private readonly component: ComponentEx;\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 ComponentEx();\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 optionsExt: 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 = optionsExt.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.appendChild(tooltipEl);\n    }\n\n    registerAsyncEvent(\n      this.component,\n      this.on('validationMessageChanged', (anotherPropertyName, anotherValidationMessage) => {\n        if (propertyName !== anotherPropertyName) {\n          return;\n        }\n\n        validationMessage = anotherValidationMessage;\n        updateValidatorElDebounced();\n      })\n    );\n\n    let shouldEmptyOnBlur = false;\n    let shouldRevertToDefaultValueOnBlur = false;\n\n    if (textBasedComponent && optionsExt.shouldShowPlaceholderForDefaultValues && deepEqual(readonlyValue, defaultValue)) {\n      textBasedComponent.empty();\n    } else {\n      valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(readonlyValue));\n    }\n\n    let shouldSkipOnChange = false;\n    const UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS = 100;\n    const updateValidatorElDebounced = 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 = undefined;\n      let shouldSetProperty = true;\n      shouldRevertToDefaultValueOnBlur = !!textBasedComponent?.isEmpty() && optionsExt.shouldResetSettingWhenComponentIsEmpty;\n      if (shouldRevertToDefaultValueOnBlur) {\n        newValue = defaultValue;\n      } else {\n        const convertedValue = optionsExt.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 && optionsExt.shouldShowPlaceholderForDefaultValues && !textBasedComponent.isEmpty() && deepEqual(newValue, defaultValue)) {\n          shouldEmptyOnBlur = true;\n        }\n      }\n\n      updateValidatorElDebounced();\n      if (shouldSetProperty) {\n        await optionsExt.onChanged(newValue as ReadonlyDeep<PropertyType>, oldValue);\n      }\n      this.saveSettingsDebounced();\n    }));\n\n    validatorEl?.addEventListener('focus', () => {\n      updateValidatorElDebounced();\n    });\n    validatorEl?.addEventListener('blur', () => {\n      updateValidatorElDebounced();\n    });\n    validatorEl?.addEventListener('click', () => {\n      window.requestAnimationFrame(() => {\n        updateValidatorElDebounced();\n      });\n    });\n\n    const validationMessages = this.pluginSettingsComponent.settingsState.validationMessages as Record<string, string>;\n    validationMessage = validationMessages[propertyName] ?? '';\n    updateValidatorElDebounced();\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 (optionsExt.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.\n   *\n   * Temporary workaround to avoid dealing with `@deprecated`.\n   */\n  public displayLegacy(): void {\n    this.containerEl.empty();\n    this._isOpen = true;\n    this.component.load();\n    registerAsyncEvent(this.component, this.pluginSettingsComponent.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this.component, this.pluginSettingsComponent.on('saveSettings', (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));\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.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   * Shows the plugin settings tab.\n   */\n  public show(): void {\n    this.app.setting.openTab(this);\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.displayLegacy();\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  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 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.displayLegacy();\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": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/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 {\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  debounce,\n  PluginSettingTab,\n  setTooltip\n} from 'obsidian';\n\nimport type { StringKeys } from '../../type.ts';\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 { mixinAsyncEvents } from '../../async-events.ts';\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../async.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport {\n  castTo,\n  deepEqual,\n  normalizeOptionalProperties\n} from '../../object-utils.ts';\nimport { assertNonNullable } from '../../type-guards.ts';\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  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  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  onLoadSettings(loadedState: ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad: boolean): Promisable<void>;\n\n  /**\n   * Called when the plugin settings are saved.\n   */\n  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 = 2_000;\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 optionsExt: 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 = optionsExt.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.appendChild(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        updateValidatorElDebounced();\n      })\n    );\n\n    let shouldEmptyOnBlur = false;\n    let shouldRevertToDefaultValueOnBlur = false;\n\n    if (textBasedComponent && optionsExt.shouldShowPlaceholderForDefaultValues && deepEqual(readonlyValue, defaultValue)) {\n      textBasedComponent.empty();\n    } else {\n      valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(readonlyValue));\n    }\n\n    let shouldSkipOnChange = false;\n    const UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS = 100;\n    const updateValidatorElDebounced = 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 = undefined;\n      let shouldSetProperty = true;\n      shouldRevertToDefaultValueOnBlur = !!textBasedComponent?.isEmpty() && optionsExt.shouldResetSettingWhenComponentIsEmpty;\n      if (shouldRevertToDefaultValueOnBlur) {\n        newValue = defaultValue;\n      } else {\n        const convertedValue = optionsExt.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 && optionsExt.shouldShowPlaceholderForDefaultValues && !textBasedComponent.isEmpty() && deepEqual(newValue, defaultValue)) {\n          shouldEmptyOnBlur = true;\n        }\n      }\n\n      updateValidatorElDebounced();\n      if (shouldSetProperty) {\n        await optionsExt.onChanged(newValue as ReadonlyDeep<PropertyType>, oldValue);\n      }\n      this.saveSettingsDebounced();\n    }));\n\n    validatorEl?.addEventListener('focus', () => {\n      updateValidatorElDebounced();\n    });\n    validatorEl?.addEventListener('blur', () => {\n      updateValidatorElDebounced();\n    });\n    validatorEl?.addEventListener('click', () => {\n      window.requestAnimationFrame(() => {\n        updateValidatorElDebounced();\n      });\n    });\n\n    const validationMessages = this.pluginSettingsComponent.settingsState.validationMessages as Record<string, string>;\n    validationMessage = validationMessages[propertyName] ?? '';\n    updateValidatorElDebounced();\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 (optionsExt.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 ODU'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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,sBAIO;AAYP,0BAAiC;AACjC,mBAGO;AACP,sBAGO;AACP,0BAIO;AACP,yBAAkC;AAClC,oCAAmC;AACnC,0BAA4B;AAC5B,uBAAyB;AACzB,uCAA8B;AAC9B,kCAA2C;AAC3C,iCAAsC;AACtC,wBAA+B;AAC/B,wBAA0C;AAC1C,4BAAoC;AAK7B,MAAM,uBAAuB;AA4SpC,MAAM,yCAAwE,gCAAY;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAA2E;AAC5F,UAAM;AACN,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKgB,SAAe;AAC7B,UAAM,OAAO;AACb,UAAM,EAAE,wBAAwB,IAAI,KAAK;AACzC,0DAAmB,MAAM,wBAAwB,GAAG,gBAAgB,CAAC,aAAa,kBAAkB,KAAK,OAAO,eAAe,aAAa,aAAa,CAAC,CAAC;AAC3J,0DAAmB,MAAM,wBAAwB,GAAG,gBAAgB,CAAC,UAAU,UAAU,YAAY,KAAK,OAAO,eAAe,UAAU,UAAU,OAAO,CAAC,CAAC;AAAA,EAC/J;AACF;AAQO,MAAe,kCAA6D,sCAAgD,EAAE,gCAAgB,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMrJ,IAAW,SAAkB;AAC3B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOnB,IAAc,4CAAoD;AAChE,UAAM,UAAU;AAChB,WAAO;AAAA,EACT;AAAA,EAEQ,UAAU;AAAA,EACD;AAAA,EACT,yBAA6C;AAAA,EACpC;AAAA,EAEjB,IAAY,iBAAyD;AACnE,WAAO,KAAK,wBAAwB,cAAc;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,YAAY,QAAgE;AACjF,UAAM,OAAO,OAAO,KAAK,OAAO,MAAM;AACtC,SAAK,0BAA0B,OAAO;AACtC,mDAAoB,KAAK,aAAa,0BAAS,iBAAiB;AAChE,SAAK,4BAAwB;AAAA,UAC3B,iCAAmB,MAAM,KAAK,wBAAwB,WAAW,oBAAoB,CAAC;AAAA,MACtF,KAAK;AAAA,IACP;AACA,SAAK,YAAY,IAAI,iCAAiD;AAAA,MACpE,gBAAgB,CAAC,aAAa,kBAAoC,KAAK,eAAe,aAAa,aAAa;AAAA,MAChH,gBAAgB,CAAC,UAAU,UAAU,YAA8B,KAAK,eAAe,EAAE,SAAS,UAAU,SAAS,CAAC;AAAA,MACtH,yBAAyB,KAAK;AAAA,IAChC,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAyCO,KAKL,QACiB;AACjB,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA,GAAG;AAAA,IACL,IAAI;AAEJ,UAAM,kBAAwF;AAAA,MAC5F,yCAAyC,CAAC,UAAiC;AAAA,MAC3E,WAAW;AAAA,MACX,yCAAyC,CAAC,UAA+C;AAAA,MACzF,wCAAwC;AAAA,MACxC,uCAAuC;AAAA,MACvC,6BAA6B;AAAA,IAC/B;AAEA,UAAM,aAAmF,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAE1H,UAAM,kBAAc,kDAAsB,cAAc,GAAG;AAE3D,UAAM,yBAAqB,wDAA2B,cAAc;AAEpE,UAAM,gBAAgB,KAAK,0BAA0B,YAAY;AACjE,UAAM,WAAW,KAAK,wBAAwB;AAC9C,UAAM,eAAe,SAAS,YAAY;AAC1C,UAAM,wBAAwB,WAAW,wCAAwC,YAA0C;AAC3H,wBAAoB,oBAAoB,qBAAqB;AAE7D,QAAI;AACJ,QAAI,YAAgC;AACpC,QAAI,mBAAuC;AAC3C,QAAI,aAAa;AACf,YAAM,cAAU,gDAAc,WAAW;AACzC,kBAAY,QAAQ,UAAU;AAC9B,qDAAoB,WAAW,CAAC,0BAAS,SAAS,0BAAS,gBAAgB,CAAC;AAC5E,yBAAmB,UAAU,WAAW;AACxC,YAAM,iBAAiB,UAAU,UAAU;AAC3C,qDAAoB,gBAAgB,0BAAS,YAAY;AACzD,gBAAU,KAAK;AACf,cAAQ,YAAY,SAAS;AAAA,IAC/B;AAEA;AAAA,MACE,KAAK,mBAAmB;AAAA,MACxB,KAAK,GAAG,4BAA4B,CAAC,qBAAqB,6BAA6B;AACrF,YAAI,iBAAiB,qBAAqB;AACxC;AAAA,QACF;AAEA,4BAAoB;AACpB,mCAA2B;AAAA,MAC7B,CAAC;AAAA,IACH;AAEA,QAAI,oBAAoB;AACxB,QAAI,mCAAmC;AAEvC,QAAI,sBAAsB,WAAW,6CAAyC,+BAAU,eAAe,YAAY,GAAG;AACpH,yBAAmB,MAAM;AAAA,IAC3B,OAAO;AACL,qBAAe,SAAS,WAAW,wCAAwC,aAAa,CAAC;AAAA,IAC3F;AAEA,QAAI,qBAAqB;AACzB,UAAM,8CAA8C;AACpD,UAAM,iCAA6B,0BAAS,MAAM;AAChD,aAAO,sBAAsB,MAAM;AACjC,0BAAkB;AAAA,MACpB,CAAC;AAAA,IACH,GAAG,2CAA2C;AAE9C,mBAAe,aAAS,iCAAmB,OAAO,YAAY;AAC5D,UAAI,oBAAoB;AACtB,6BAAqB;AACrB;AAAA,MACF;AAEA,0BAAoB;AAEpB,YAAM,WAAW,KAAK,0BAA0B,YAAY;AAC5D,UAAI,WAAqC;AACzC,UAAI,oBAAoB;AACxB,yCAAmC,CAAC,CAAC,oBAAoB,QAAQ,KAAK,WAAW;AACjF,UAAI,kCAAkC;AACpC,mBAAW;AAAA,MACb,OAAO;AACL,cAAM,iBAAiB,WAAW,wCAAwC,OAAO;AACjF,gBAAI,6CAA0B,cAAc,GAAG;AAC7C,8BAAoB,eAAe;AACnC,8BAAoB;AAAA,QACtB,OAAO;AACL,qBAAW;AAAA,QACb;AAAA,MACF;AAEA,UAAI,mBAAmB;AACrB,4BAAoB,MAAM,KAAK,wBAAwB,YAAY,cAAc,QAAwC;AACzH,YAAI,sBAAsB,WAAW,yCAAyC,CAAC,mBAAmB,QAAQ,SAAK,+BAAU,UAAU,YAAY,GAAG;AAChJ,8BAAoB;AAAA,QACtB;AAAA,MACF;AAEA,iCAA2B;AAC3B,UAAI,mBAAmB;AACrB,cAAM,WAAW,UAAU,UAAwC,QAAQ;AAAA,MAC7E;AACA,WAAK,sBAAsB;AAAA,IAC7B,CAAC,CAAC;AAEF,iBAAa,iBAAiB,SAAS,MAAM;AAC3C,iCAA2B;AAAA,IAC7B,CAAC;AACD,iBAAa,iBAAiB,QAAQ,MAAM;AAC1C,iCAA2B;AAAA,IAC7B,CAAC;AACD,iBAAa,iBAAiB,SAAS,MAAM;AAC3C,aAAO,sBAAsB,MAAM;AACjC,mCAA2B;AAAA,MAC7B,CAAC;AAAA,IACH,CAAC;AAED,UAAM,qBAAqB,KAAK,wBAAwB,cAAc;AACtE,wBAAoB,mBAAmB,YAAY,KAAK;AACxD,+BAA2B;AAE3B,WAAO;AAEP,aAAS,oBAA0B;AACjC,UAAI,CAAC,aAAa,gBAAgB,GAAG;AACnC,YAAI,mBAAmB;AACrB,8BAAoB;AAEpB,cAAI,CAAC,oBAAoB,QAAQ,GAAG;AAClC,iCAAqB;AACrB,gCAAoB,MAAM;AAAA,UAC5B;AAAA,QACF,WAAW,kCAAkC;AAC3C,6CAAmC;AAEnC,cAAI,oBAAoB,QAAQ,GAAG;AACjC,iCAAqB;AACrB,2BAAe,SAAS,qBAAqB;AAAA,UAC/C;AAAA,QACF;AAAA,MACF;AAEA,UAAI,CAAC,aAAa;AAChB;AAAA,MACF;AAEA,gDAAkB,gBAAgB;AAElC,UAAI,sBAAsB,IAAI;AAC5B,oBAAY,kBAAkB,EAAE;AAChC,oBAAY,cAAc;AAC1B,4BAAoB,YAAY;AAAA,MAClC;AAEA,kBAAY,kBAAkB,iBAAiB;AAC/C,UAAI,WAAW,6BAA6B;AAC1C,yBAAiB,cAAc;AAC/B,mBAAW,OAAO,CAAC,CAAC,iBAAiB;AAAA,MACvC,WAAW,mBAAmB;AAC5B,wCAAW,aAAa,iBAAiB;AAAA,MAC3C;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKgB,UAAgB;AAC9B,SAAK,cAAc;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,gBAAsB;AAC3B,SAAK,iBAAiB;AACtB,SAAK,YAAY,MAAM;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYgB,gBAAgB,KAAsB;AACpD,WAAO,KAAK,8BAA0B,4BAAmC,GAAG,CAAC;AAAA,EAC/E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUgB,wBAAiD;AAC/D,WAAO,KAAK,0BAA0B;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA,EAKgB,OAAa;AAC3B,UAAM,KAAK;AACX,SAAK,sBAAsB,OAAO;AAClC,SAAK,UAAU;AACf,SAAK,eAAe;AACpB,SAAK,UAAU,OAAO;AACtB,wCAAkB,MAAM,KAAK,UAAU,CAAC;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAa,YAA2B;AACtC,UAAM,KAAK,wBAAwB,WAAW,oBAAoB;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,UAAgB;AACrB,SAAK,OAAO;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAsB,gBAAgB,KAAa,OAA+B;AAEhF,UAAM,KAAK,wBAAwB,gBAAY,4BAAqB,GAAG,OAAG,4BAAqC,KAAK,CAAC;AACrH,SAAK,sBAAsB;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA,EAKO,OAAa;AAClB,SAAK,IAAI,QAAQ,QAAQ,IAAI;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBU,4BAAqD;AAC7D,WAAO,CAAC;AAAA,EACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAgB,eAAe,cAA2D,gBAAwC;AAChI,SAAK,QAAQ;AACb,cAAM,2BAAU;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAgB,aAA4B;AAC1C,UAAM,qBAAqB,MAAM,KAAK,wBAAwB,WAAW;AACzE,UAAM,KAAK,kBAAkB,kBAAkB;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcU,UAAU,QAAuE;AACzF,eAAO,iDAAqD;AAAA,MAC1D,SAAS,OAAO;AAAA,MAChB,MAAM,OAAO;AAAA,MACb,UAAU,OAAO;AAAA,MACjB,MAAM,OAAO;AAAA,MACb,QAAQ,CAAC,SAAkB,UAAwB,KAAK,gBAAgB,EAAE,OAAO,SAAS,iBAAiB,OAAO,CAAC;AAAA,MACnH,YAAY,OAAO;AAAA,MACnB,SAAS,OAAO;AAAA,IAClB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYU,eAAe,QAA2E;AAClG,eAAO,iDAAoD;AAAA,MACzD,GAAG;AAAA,MACH,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AAAA,EAEQ,mBAAyB;AAC/B,SAAK,eAAe;AACpB,SAAK,yBAAyB,KAAK,sBAAsB;AAAA,EAC3D;AAAA,EAEQ,wBAAqC;AAC3C,SAAK,UAAU;AACf,SAAK,UAAU,KAAK;AACpB,WAAO,KAAK,UAAU,SAAS,IAAI,gCAAY,CAAC;AAAA,EAClD;AAAA,EAEQ,iBAAuB;AAC7B,UAAM,kBAAkB,KAAK;AAC7B,QAAI,CAAC,iBAAiB;AACpB;AAAA,IACF;AAEA,SAAK,yBAAyB;AAC9B,SAAK,UAAU,YAAY,eAAe;AAAA,EAC5C;AAAA,EAEQ,0BACN,cAC4C;AAC5C,UAAM,WAAW,KAAK;AACtB,WAAO,SAAS,YAAY;AAAA,EAC9B;AAAA,EAEQ,qBAAkC;AACxC,SAAK,2BAA2B,KAAK,sBAAsB;AAC3D,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAc,eAAe,QAAkF;AAC7G,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA,UAAU;AAAA,IACZ,IAAI;AACJ,QAAI,YAAY,sBAAsB;AACpC,YAAM,KAAK,kBAAkB,SAAS,kBAAgE;AACtG;AAAA,IACF;AAEA,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA,EAGQ,gBAAgB,QAAyE;AAC/F,UAAM,eAAe,KAAK,sBAAsB;AAChD,UAAM,0BAA0B,KAAK;AACrC,SAAK,yBAAyB;AAE9B,QAAI;AACF,YAAM,UAAU,OAAO,gBAAgB,WAAO,kCAAe,OAAO,OAAO,GAAG,OAAO,KAAK;AAC1F,aAAO,MAAM;AACX,YAAI,OAAO,YAAY,YAAY;AACjC,kBAAQ;AAAA,QACV;AAEA,aAAK,UAAU,YAAY,YAAY;AAAA,MACzC;AAAA,IACF,UAAE;AACA,WAAK,yBAAyB;AAAA,IAChC;AAAA,EACF;AAAA,EAEA,MAAc,kBAAkB,oBAA+E;AAC7G,eAAW,CAAC,cAAc,iBAAiB,KAAK,OAAO,QAAQ,kBAAkB,GAAG;AAClF,YAAM,KAAK,aAAa,4BAA4B,cAAc,iBAA2B;AAAA,IAC/F;AAAA,EACF;AACF;",
  "names": []
}
