obsidian-dev-utils 22.1.1-beta.2 → 22.1.1-beta.21

package/dist/lib/cjs/obsidian/Plugin/PluginSettingsManagerBase.d.cts

@@ -1,30 +1,24 @@
-import type { ReadonlyDeep } from 'type-fest';
-import { Plugin } from 'obsidian';
-import type { StringKeys } from '../../Object.cjs';
+import type { App } from 'obsidian';
+import type { Promisable, ReadonlyDeep } from 'type-fest';
 import type { Transformer } from '../../Transformers/Transformer.cjs';
-declare class PluginSettingsProperty<PluginSettings extends object, Property extends StringKeys<PluginSettings>> {
-    private readonly manager;
-    private readonly property;
-    readonly defaultValue: PluginSettings[Property];
-    validationMessage: string;
-    private value;
-    constructor(manager: PluginSettingsManagerBase<PluginSettings>, property: Property, defaultValue: PluginSettings[Property]);
-    clear(): void;
-    get(): PluginSettings[Property];
-    getSafe(): PluginSettings[Property];
-    set(value: PluginSettings[Property] | undefined): Promise<void>;
-}
+import type { MaybeReturn, StringKeys } from '../../Type.cjs';
+import type { PluginBase } from './PluginBase.cjs';
+type Validator<T> = (value: T) => Promisable<MaybeReturn<string>>;
 /**
  * Base class for managing plugin settings.
  *
  * @typeParam PluginSettings - The type representing the plugin settings object.
  */
 export declare abstract class PluginSettingsManagerBase<PluginSettings extends object> {
-    private plugin;
+    readonly plugin: PluginBase<PluginSettings>;
+    readonly app: App;
     readonly safeSettings: ReadonlyDeep<PluginSettings>;
+    private defaultSettings;
     private properties;
-    constructor(plugin: Plugin);
-    getProperty<Property extends StringKeys<PluginSettings>>(property: Property): PluginSettingsProperty<PluginSettings, Property>;
+    private validators;
+    constructor(plugin: PluginBase<PluginSettings>);
+    editAndSave(editor: (settings: PluginSettings) => Promisable<void>): Promise<void>;
+    getProperty<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName): PluginSettingsProperty<PluginSettings[PropertyName]>;
     loadFromFile(): Promise<void>;
     /**
      * Saves the new plugin settings.
@@ -32,10 +26,50 @@ export declare abstract class PluginSettingsManagerBase<PluginSettings extends o
      * @returns A promise that resolves when the settings are saved.
      */
     saveToFile(): Promise<void>;
-    validate<Property extends StringKeys<PluginSettings>>(_property: Property, _value: PluginSettings[Property]): Promise<string | void>;
+    protected addValidator<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName, validator: Validator<PluginSettings[PropertyName]>): void;
+    protected addValidators(): void;
     protected abstract createDefaultSettings(): PluginSettings;
     protected getTransformer(): Transformer;
-    protected prepareRecord(_record: Record<string, unknown>): Promise<void>;
-    private getSettings;
+    /**
+     * Called when the plugin settings are loaded.
+     *
+     * @param _record - The record.
+     * @returns A promise or `void` indicating the completion of the load process
+     */
+    protected onLoadRecord(_record: Record<string, unknown>): Promisable<void>;
+    /**
+     * Called when the plugin settings are saving.
+     *
+     * @param _record - The record.
+     * @returns A promise or `void` indicating the completion of the save process
+     */
+    protected onSavingRecord(_record: Record<string, unknown>): Promisable<void>;
+    private getSavedSettings;
+    private prepareRecordToSave;
+    private saveToFileImpl;
+}
+/**
+ * A property of a plugin settings.
+ *
+ * @typeParam T - The type of the property.
+ */
+export declare class PluginSettingsProperty<T> {
+    private readonly propertyName;
+    readonly defaultValue: T;
+    private readonly validator;
+    get currentValue(): T;
+    get lastSavedValue(): T;
+    get safeValue(): T;
+    get validationMessage(): string;
+    private _currentValue;
+    private _lastSavedValue;
+    private _validationMessage;
+    constructor(propertyName: string, defaultValue: T, validator: Validator<T>);
+    reset(): void;
+    save(): boolean;
+    setValidationMessage(validationMessage: string): void;
+    setValue(value: T): void;
+    setValueAndValidate(value: T): Promise<void>;
+    private showWarning;
 }
 export {};

package/dist/lib/cjs/obsidian/Plugin/PluginSettingsTabBase.cjs

@@ -32,7 +32,9 @@ var import_obsidian = require('obsidian');
 var import_Async = require('../../Async.cjs');
 var import_CssClass = require('../../CssClass.cjs');
 var import_Function = require('../../Function.cjs');
+var import_TextBasedComponent = require('../Components/TextBasedComponent.cjs');
 var import_ValidatorComponent = require('../Components/ValidatorComponent.cjs');
+var import_ValidationMessage = require('../ValidationMessage.cjs');
 var import_PluginId = require('./PluginId.cjs');
 class PluginSettingsTabBase extends import_obsidian.PluginSettingTab {
   constructor(plugin) {
@@ -45,32 +47,46 @@ class PluginSettingsTabBase extends import_obsidian.PluginSettingTab {
    *
    * @typeParam UIValue - The type of the value of the UI component.
    * @typeParam TValueComponent - The type of the value component.
-   * @typeParam Property - The property of the plugin settings to bind to.
+   * @typeParam PropertyName - The property name of the plugin settings to bind to.
    * @param valueComponent - The value component to bind.
-   * @param property - The property of the plugin settings to bind to.
+   * @param propertyName - The property name of the plugin settings to bind to.
    * @param options - The options for binding the value component.
    * @returns The value component.
    */
-  bind(valueComponent, property, options) {
+  bind(valueComponent, propertyName, options) {
     const DEFAULT_OPTIONS = {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      componentToPluginSettingsValueConverter: (value) => value,
+      componentToPluginSettingsValueConverter: (value2) => value2,
       onChanged: import_Function.noop,
-      pluginSettingsToComponentValueConverter: (value) => value,
+      pluginSettingsToComponentValueConverter: (value2) => value2,
+      shouldResetSettingWhenComponentIsEmpty: true,
       shouldShowValidationMessage: true
     };
     const optionsExt = { ...DEFAULT_OPTIONS, ...options };
     const validatorElement = (0, import_ValidatorComponent.getValidatorComponent)(valueComponent)?.validatorEl;
-    const propertyObj = this.plugin.settingsManager.getProperty(property);
-    valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(propertyObj.get())).onChange(async (uiValue) => {
+    const property = this.plugin.settingsManager.getProperty(propertyName);
+    const value = property.currentValue;
+    const textBasedComponent = (0, import_TextBasedComponent.getTextBasedComponentValue)(valueComponent);
+    textBasedComponent?.setPlaceholderValue(optionsExt.pluginSettingsToComponentValueConverter(property.defaultValue));
+    if (property.currentValue === property.defaultValue && textBasedComponent && optionsExt.shouldResetSettingWhenComponentIsEmpty) {
+      textBasedComponent.empty();
+    } else {
+      valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(value));
+    }
+    valueComponent.onChange(async (uiValue) => {
+      if (textBasedComponent?.isEmpty() && optionsExt.shouldResetSettingWhenComponentIsEmpty) {
+        property.reset();
+        return;
+      }
+      const oldValue = property.currentValue;
       const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);
-      if (isValidationMessageHolder(convertedValue)) {
-        propertyObj.validationMessage = convertedValue.validationMessage;
-        await propertyObj.set(void 0);
+      if ((0, import_ValidationMessage.isValidationMessageHolder)(convertedValue)) {
+        property.setValidationMessage(convertedValue.validationMessage);
       } else {
-        await propertyObj.set(convertedValue);
+        await property.setValueAndValidate(convertedValue);
       }
-      await optionsExt.onChanged();
+      const newValue = (0, import_ValidationMessage.isValidationMessageHolder)(convertedValue) ? void 0 : convertedValue;
+      await optionsExt.onChanged(newValue, oldValue);
     });
     validatorElement?.addEventListener("focus", validate);
     validatorElement?.addEventListener("blur", validate);
@@ -80,13 +96,13 @@ class PluginSettingsTabBase extends import_obsidian.PluginSettingTab {
       if (!validatorElement) {
         return;
       }
-      if (!propertyObj.validationMessage) {
+      if (!property.validationMessage) {
         validatorElement.setCustomValidity("");
         validatorElement.checkValidity();
-        propertyObj.validationMessage = validatorElement.validationMessage;
+        property.setValidationMessage(validatorElement.validationMessage);
       }
-      validatorElement.setCustomValidity(propertyObj.validationMessage);
-      validatorElement.title = propertyObj.validationMessage;
+      validatorElement.setCustomValidity(property.validationMessage);
+      (0, import_obsidian.setTooltip)(validatorElement, property.validationMessage);
       if (validatorElement.isActiveElement() && optionsExt.shouldShowValidationMessage) {
         validatorElement.reportValidity();
       }
@@ -97,11 +113,8 @@ class PluginSettingsTabBase extends import_obsidian.PluginSettingTab {
     (0, import_Async.invokeAsyncSafely)(() => this.plugin.settingsManager.saveToFile());
   }
 }
-function isValidationMessageHolder(value) {
-  return !!value.validationMessage;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PluginSettingsTabBase
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsTabBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation PluginSettingsTabBase\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  ConditionalKeys,\n  Promisable,\n  WritableDeep\n} from 'type-fest';\n\nimport { PluginSettingTab } from 'obsidian';\n\nimport type { StringKeys } from '../../Object.ts';\nimport type { ValueComponentWithChangeTracking } from '../Components/ValueComponentWithChangeTracking.ts';\nimport type { PluginBase } from './PluginBase.ts';\n\nimport { invokeAsyncSafely } from '../../Async.ts';\nimport { CssClass } from '../../CssClass.ts';\nimport { noop } from '../../Function.ts';\nimport { getValidatorComponent } from '../Components/ValidatorComponent.ts';\nimport { getPluginId } from './PluginId.ts';\n\n/**\n * Options for binding a value component to a plugin setting.\n */\nexport interface BindOptions {\n  /**\n   * A callback function that is called when the value of the component changes.\n   */\n  onChanged?(): Promisable<void>;\n\n  /**\n   * If true, shows the validation message when the component value is invalid. Default is `true`.\n   */\n  shouldShowValidationMessage?: boolean;\n}\n\n/**\n * Extended options for binding a value component to a plugin setting.\n */\nexport interface BindOptionsExtended<PluginSettings extends object, UIValue, Property extends StringKeys<PluginSettings>> extends BindOptions {\n  /**\n   * Converts the UI component's value back to the plugin settings value.\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[Property] | ValidationMessageHolder;\n\n  /**\n   * Converts the plugin settings value to the value used by the UI component.\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: PluginSettings[Property]) => UIValue;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ExtractPluginSettings<T extends PluginBase<any>> = WritableDeep<T['settings']>;\n\ninterface ValidationMessageHolder {\n  validationMessage: string;\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 TPlugin - The type of the plugin that extends PluginBase.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport abstract class PluginSettingsTabBase<TPlugin extends PluginBase<any>> extends PluginSettingTab {\n  public constructor(public override plugin: TPlugin) {\n    super(plugin.app, plugin);\n    this.containerEl.addClass(CssClass.LibraryName, getPluginId(), CssClass.PluginSettingsTab);\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 valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: ConditionalKeys<ExtractPluginSettings<TPlugin>, UIValue>,\n    options?: BindOptions\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 Property - The property of the plugin settings to bind to.\n   * @param valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    Property extends StringKeys<ExtractPluginSettings<TPlugin>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: Property,\n    options: BindOptionsExtended<ExtractPluginSettings<TPlugin>, UIValue, Property>\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 Property - The property of the plugin settings to bind to.\n   * @param valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    Property extends StringKeys<ExtractPluginSettings<TPlugin>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: Property,\n    options?: BindOptions\n  ): TValueComponent {\n    type PluginSettings = ExtractPluginSettings<TPlugin>;\n    type PropertyType = PluginSettings[Property];\n    const DEFAULT_OPTIONS: Required<BindOptionsExtended<PluginSettings, UIValue, Property>> = {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      componentToPluginSettingsValueConverter: (value: UIValue): PropertyType => value as PropertyType,\n      onChanged: noop,\n      pluginSettingsToComponentValueConverter: (value: PropertyType): UIValue => value as UIValue,\n      shouldShowValidationMessage: true\n    };\n\n    const optionsExt: Required<BindOptionsExtended<PluginSettings, UIValue, Property>> = { ...DEFAULT_OPTIONS, ...options };\n\n    const validatorElement = getValidatorComponent(valueComponent)?.validatorEl;\n\n    const propertyObj = this.plugin.settingsManager.getProperty(property);\n\n    valueComponent\n      .setValue(optionsExt.pluginSettingsToComponentValueConverter(propertyObj.get() as PropertyType))\n      .onChange(async (uiValue) => {\n        const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);\n        if (isValidationMessageHolder(convertedValue)) {\n          propertyObj.validationMessage = convertedValue.validationMessage;\n          await propertyObj.set(undefined);\n        } else {\n          await propertyObj.set(convertedValue);\n        }\n        await optionsExt.onChanged();\n      });\n\n    validatorElement?.addEventListener('focus', validate);\n    validatorElement?.addEventListener('blur', validate);\n\n    validate();\n    return valueComponent;\n\n    function validate(): void {\n      if (!validatorElement) {\n        return;\n      }\n\n      if (!propertyObj.validationMessage) {\n        validatorElement.setCustomValidity('');\n        validatorElement.checkValidity();\n        propertyObj.validationMessage = validatorElement.validationMessage;\n      }\n\n      validatorElement.setCustomValidity(propertyObj.validationMessage);\n      validatorElement.title = propertyObj.validationMessage;\n      if (validatorElement.isActiveElement() && optionsExt.shouldShowValidationMessage) {\n        validatorElement.reportValidity();\n      }\n    }\n  }\n\n  public override hide(): void {\n    super.hide();\n    invokeAsyncSafely(() => this.plugin.settingsManager.saveToFile());\n  }\n}\n\nfunction isValidationMessageHolder(value: unknown): value is ValidationMessageHolder {\n  return !!(value as Partial<ValidationMessageHolder>).validationMessage;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,sBAAiC;AAMjC,mBAAkC;AAClC,sBAAyB;AACzB,sBAAqB;AACrB,gCAAsC;AACtC,sBAA4B;AAkDrB,MAAe,8BAA+D,iCAAiB;AAAA,EAC7F,YAA4B,QAAiB;AAClD,UAAM,OAAO,KAAK,MAAM;AADS;AAEjC,SAAK,YAAY,SAAS,yBAAS,iBAAa,6BAAY,GAAG,yBAAS,iBAAiB;AAAA,EAC3F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmDO,KAKL,gBACA,UACA,SACiB;AAGjB,UAAM,kBAAoF;AAAA;AAAA,MAExF,yCAAyC,CAAC,UAAiC;AAAA,MAC3E,WAAW;AAAA,MACX,yCAAyC,CAAC,UAAiC;AAAA,MAC3E,6BAA6B;AAAA,IAC/B;AAEA,UAAM,aAA+E,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAEtH,UAAM,uBAAmB,iDAAsB,cAAc,GAAG;AAEhE,UAAM,cAAc,KAAK,OAAO,gBAAgB,YAAY,QAAQ;AAEpE,mBACG,SAAS,WAAW,wCAAwC,YAAY,IAAI,CAAiB,CAAC,EAC9F,SAAS,OAAO,YAAY;AAC3B,YAAM,iBAAiB,WAAW,wCAAwC,OAAO;AACjF,UAAI,0BAA0B,cAAc,GAAG;AAC7C,oBAAY,oBAAoB,eAAe;AAC/C,cAAM,YAAY,IAAI,MAAS;AAAA,MACjC,OAAO;AACL,cAAM,YAAY,IAAI,cAAc;AAAA,MACtC;AACA,YAAM,WAAW,UAAU;AAAA,IAC7B,CAAC;AAEH,sBAAkB,iBAAiB,SAAS,QAAQ;AACpD,sBAAkB,iBAAiB,QAAQ,QAAQ;AAEnD,aAAS;AACT,WAAO;AAEP,aAAS,WAAiB;AACxB,UAAI,CAAC,kBAAkB;AACrB;AAAA,MACF;AAEA,UAAI,CAAC,YAAY,mBAAmB;AAClC,yBAAiB,kBAAkB,EAAE;AACrC,yBAAiB,cAAc;AAC/B,oBAAY,oBAAoB,iBAAiB;AAAA,MACnD;AAEA,uBAAiB,kBAAkB,YAAY,iBAAiB;AAChE,uBAAiB,QAAQ,YAAY;AACrC,UAAI,iBAAiB,gBAAgB,KAAK,WAAW,6BAA6B;AAChF,yBAAiB,eAAe;AAAA,MAClC;AAAA,IACF;AAAA,EACF;AAAA,EAEgB,OAAa;AAC3B,UAAM,KAAK;AACX,wCAAkB,MAAM,KAAK,OAAO,gBAAgB,WAAW,CAAC;AAAA,EAClE;AACF;AAEA,SAAS,0BAA0B,OAAkD;AACnF,SAAO,CAAC,CAAE,MAA2C;AACvD;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsTabBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation PluginSettingsTabBase\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  ConditionalKeys,\n  Promisable\n} from 'type-fest';\n\nimport {\n  PluginSettingTab,\n  setTooltip\n} from 'obsidian';\n\nimport type { StringKeys } from '../../Type.ts';\nimport type { ValueComponentWithChangeTracking } from '../Components/ValueComponentWithChangeTracking.ts';\nimport type { ValidationMessageHolder } from '../ValidationMessage.ts';\nimport type { PluginBase } from './PluginBase.ts';\nimport type { PluginSettingsProperty } from './PluginSettingsManagerBase.ts';\n\nimport { invokeAsyncSafely } from '../../Async.ts';\nimport { CssClass } from '../../CssClass.ts';\nimport { noop } from '../../Function.ts';\nimport { getTextBasedComponentValue } from '../Components/TextBasedComponent.ts';\nimport { getValidatorComponent } from '../Components/ValidatorComponent.ts';\nimport { isValidationMessageHolder } from '../ValidationMessage.ts';\nimport { getPluginId } from './PluginId.ts';\n\n/**\n * Options for binding a value component to a plugin setting.\n */\nexport interface BindOptions<T> {\n  /**\n   * A callback function that is called when the value of the component changes.\n   */\n  onChanged?(newValue: T | undefined, oldValue: T): Promisable<void>;\n\n  /**\n   * Whether to reset the setting when the component value is empty. Default is `true`.\n   * Applicable only to text-based components.\n   */\n  shouldResetSettingWhenComponentIsEmpty?: boolean;\n\n  /**\n   * Whether to show the validation message when the component value is invalid. Default is `true`.\n   */\n  shouldShowValidationMessage?: boolean;\n}\n\n/**\n * Extended options for binding a value component to a plugin setting.\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   * @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   * @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: PluginSettings[PropertyName]) => UIValue;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ExtractPluginSettings<Plugin extends PluginBase<any>> = Plugin['__pluginSettingsType'];\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 TPlugin - The type of the plugin that extends PluginBase.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport abstract class PluginSettingsTabBase<TPlugin extends PluginBase<any>> extends PluginSettingTab {\n  public constructor(public override plugin: TPlugin) {\n    super(plugin.app, plugin);\n    this.containerEl.addClass(CssClass.LibraryName, getPluginId(), CssClass.PluginSettingsTab);\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 valueComponent - The value component to bind.\n   * @param propertyName - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: ConditionalKeys<ExtractPluginSettings<TPlugin>, UIValue>,\n    options?: BindOptions<UIValue>\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 valueComponent - The value component to bind.\n   * @param propertyName - The property name of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    PropertyName extends StringKeys<ExtractPluginSettings<TPlugin>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: PropertyName,\n    options: BindOptionsExtended<ExtractPluginSettings<TPlugin>, UIValue, 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 valueComponent - The value component to bind.\n   * @param propertyName - The property name of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    PropertyName extends StringKeys<ExtractPluginSettings<TPlugin>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: PropertyName,\n    options?: BindOptions<ExtractPluginSettings<TPlugin>[PropertyName]>\n  ): TValueComponent {\n    type PluginSettings = ExtractPluginSettings<TPlugin>;\n    type PropertyType = PluginSettings[PropertyName];\n    const DEFAULT_OPTIONS: Required<BindOptionsExtended<PluginSettings, UIValue, PropertyName>> = {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      componentToPluginSettingsValueConverter: (value: UIValue): PropertyType => value as PropertyType,\n      onChanged: noop,\n      pluginSettingsToComponentValueConverter: (value: PropertyType): UIValue => value as UIValue,\n      shouldResetSettingWhenComponentIsEmpty: true,\n      shouldShowValidationMessage: true\n    };\n\n    const optionsExt: Required<BindOptionsExtended<PluginSettings, UIValue, PropertyName>> = { ...DEFAULT_OPTIONS, ...options };\n\n    const validatorElement = getValidatorComponent(valueComponent)?.validatorEl;\n\n    const property = this.plugin.settingsManager.getProperty(propertyName) as PluginSettingsProperty<PropertyType>;\n\n    const value = property.currentValue;\n\n    const textBasedComponent = getTextBasedComponentValue(valueComponent);\n    textBasedComponent?.setPlaceholderValue(optionsExt.pluginSettingsToComponentValueConverter(property.defaultValue));\n\n    if (property.currentValue === property.defaultValue && textBasedComponent && optionsExt.shouldResetSettingWhenComponentIsEmpty) {\n      textBasedComponent.empty();\n    } else {\n      valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(value));\n    }\n\n    valueComponent.onChange(async (uiValue) => {\n      if (textBasedComponent?.isEmpty() && optionsExt.shouldResetSettingWhenComponentIsEmpty) {\n        property.reset();\n        return;\n      }\n\n      const oldValue = property.currentValue;\n      const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);\n      if (isValidationMessageHolder(convertedValue)) {\n        property.setValidationMessage(convertedValue.validationMessage);\n      } else {\n        await property.setValueAndValidate(convertedValue);\n      }\n      const newValue = isValidationMessageHolder(convertedValue) ? undefined : convertedValue;\n      await optionsExt.onChanged(newValue, oldValue);\n    });\n\n    validatorElement?.addEventListener('focus', validate);\n    validatorElement?.addEventListener('blur', validate);\n\n    validate();\n    return valueComponent;\n\n    function validate(): void {\n      if (!validatorElement) {\n        return;\n      }\n\n      if (!property.validationMessage) {\n        validatorElement.setCustomValidity('');\n        validatorElement.checkValidity();\n        property.setValidationMessage(validatorElement.validationMessage);\n      }\n\n      validatorElement.setCustomValidity(property.validationMessage);\n      setTooltip(validatorElement, property.validationMessage);\n      if (validatorElement.isActiveElement() && optionsExt.shouldShowValidationMessage) {\n        validatorElement.reportValidity();\n      }\n    }\n  }\n\n  public override hide(): void {\n    super.hide();\n    invokeAsyncSafely(() => this.plugin.settingsManager.saveToFile());\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,sBAGO;AAQP,mBAAkC;AAClC,sBAAyB;AACzB,sBAAqB;AACrB,gCAA2C;AAC3C,gCAAsC;AACtC,+BAA0C;AAC1C,sBAA4B;AAwDrB,MAAe,8BAA+D,iCAAiB;AAAA,EAC7F,YAA4B,QAAiB;AAClD,UAAM,OAAO,KAAK,MAAM;AADS;AAEjC,SAAK,YAAY,SAAS,yBAAS,iBAAa,6BAAY,GAAG,yBAAS,iBAAiB;AAAA,EAC3F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmDO,KAKL,gBACA,cACA,SACiB;AAGjB,UAAM,kBAAwF;AAAA;AAAA,MAE5F,yCAAyC,CAACA,WAAiCA;AAAA,MAC3E,WAAW;AAAA,MACX,yCAAyC,CAACA,WAAiCA;AAAA,MAC3E,wCAAwC;AAAA,MACxC,6BAA6B;AAAA,IAC/B;AAEA,UAAM,aAAmF,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAE1H,UAAM,uBAAmB,iDAAsB,cAAc,GAAG;AAEhE,UAAM,WAAW,KAAK,OAAO,gBAAgB,YAAY,YAAY;AAErE,UAAM,QAAQ,SAAS;AAEvB,UAAM,yBAAqB,sDAA2B,cAAc;AACpE,wBAAoB,oBAAoB,WAAW,wCAAwC,SAAS,YAAY,CAAC;AAEjH,QAAI,SAAS,iBAAiB,SAAS,gBAAgB,sBAAsB,WAAW,wCAAwC;AAC9H,yBAAmB,MAAM;AAAA,IAC3B,OAAO;AACL,qBAAe,SAAS,WAAW,wCAAwC,KAAK,CAAC;AAAA,IACnF;AAEA,mBAAe,SAAS,OAAO,YAAY;AACzC,UAAI,oBAAoB,QAAQ,KAAK,WAAW,wCAAwC;AACtF,iBAAS,MAAM;AACf;AAAA,MACF;AAEA,YAAM,WAAW,SAAS;AAC1B,YAAM,iBAAiB,WAAW,wCAAwC,OAAO;AACjF,cAAI,oDAA0B,cAAc,GAAG;AAC7C,iBAAS,qBAAqB,eAAe,iBAAiB;AAAA,MAChE,OAAO;AACL,cAAM,SAAS,oBAAoB,cAAc;AAAA,MACnD;AACA,YAAM,eAAW,oDAA0B,cAAc,IAAI,SAAY;AACzE,YAAM,WAAW,UAAU,UAAU,QAAQ;AAAA,IAC/C,CAAC;AAED,sBAAkB,iBAAiB,SAAS,QAAQ;AACpD,sBAAkB,iBAAiB,QAAQ,QAAQ;AAEnD,aAAS;AACT,WAAO;AAEP,aAAS,WAAiB;AACxB,UAAI,CAAC,kBAAkB;AACrB;AAAA,MACF;AAEA,UAAI,CAAC,SAAS,mBAAmB;AAC/B,yBAAiB,kBAAkB,EAAE;AACrC,yBAAiB,cAAc;AAC/B,iBAAS,qBAAqB,iBAAiB,iBAAiB;AAAA,MAClE;AAEA,uBAAiB,kBAAkB,SAAS,iBAAiB;AAC7D,sCAAW,kBAAkB,SAAS,iBAAiB;AACvD,UAAI,iBAAiB,gBAAgB,KAAK,WAAW,6BAA6B;AAChF,yBAAiB,eAAe;AAAA,MAClC;AAAA,IACF;AAAA,EACF;AAAA,EAEgB,OAAa;AAC3B,UAAM,KAAK;AACX,wCAAkB,MAAM,KAAK,OAAO,gBAAgB,WAAW,CAAC;AAAA,EAClE;AACF;",
  "names": ["value"]
}


package/dist/lib/cjs/obsidian/Plugin/PluginSettingsTabBase.d.cts

@@ -3,45 +3,48 @@
  * This module defines a base class for creating plugin setting tabs in Obsidian.
  * It provides a utility method to bind value components to plugin settings and handle changes.
  */
-import type { ConditionalKeys, Promisable, WritableDeep } from 'type-fest';
+import type { ConditionalKeys, Promisable } from 'type-fest';
 import { PluginSettingTab } from 'obsidian';
-import type { StringKeys } from '../../Object.cjs';
+import type { StringKeys } from '../../Type.cjs';
 import type { ValueComponentWithChangeTracking } from '../Components/ValueComponentWithChangeTracking.cjs';
+import type { ValidationMessageHolder } from '../ValidationMessage.cjs';
 import type { PluginBase } from './PluginBase.cjs';
 /**
  * Options for binding a value component to a plugin setting.
  */
-export interface BindOptions {
+export interface BindOptions<T> {
     /**
      * A callback function that is called when the value of the component changes.
      */
-    onChanged?(): Promisable<void>;
+    onChanged?(newValue: T | undefined, oldValue: T): Promisable<void>;
     /**
-     * If true, shows the validation message when the component value is invalid. Default is `true`.
+     * Whether to reset the setting when the component value is empty. Default is `true`.
+     * Applicable only to text-based components.
+     */
+    shouldResetSettingWhenComponentIsEmpty?: boolean;
+    /**
+     * Whether to show the validation message when the component value is invalid. Default is `true`.
      */
     shouldShowValidationMessage?: boolean;
 }
 /**
  * Extended options for binding a value component to a plugin setting.
  */
-export interface BindOptionsExtended<PluginSettings extends object, UIValue, Property extends StringKeys<PluginSettings>> extends BindOptions {
+export interface BindOptionsExtended<PluginSettings extends object, UIValue, PropertyName extends StringKeys<PluginSettings>> extends BindOptions<PluginSettings[PropertyName]> {
     /**
      * Converts the UI component's value back to the plugin settings value.
      * @param uiValue - The value of the UI component.
      * @returns The value to set on the plugin settings.
      */
-    componentToPluginSettingsValueConverter: (uiValue: UIValue) => PluginSettings[Property] | ValidationMessageHolder;
+    componentToPluginSettingsValueConverter: (uiValue: UIValue) => PluginSettings[PropertyName] | ValidationMessageHolder;
     /**
      * Converts the plugin settings value to the value used by the UI component.
      * @param pluginSettingsValue - The value of the property in the plugin settings.
      * @returns The value to set on the UI component.
      */
-    pluginSettingsToComponentValueConverter: (pluginSettingsValue: PluginSettings[Property]) => UIValue;
-}
-type ExtractPluginSettings<T extends PluginBase<any>> = WritableDeep<T['settings']>;
-interface ValidationMessageHolder {
-    validationMessage: string;
+    pluginSettingsToComponentValueConverter: (pluginSettingsValue: PluginSettings[PropertyName]) => UIValue;
 }
+type ExtractPluginSettings<Plugin extends PluginBase<any>> = Plugin['__pluginSettingsType'];
 /**
  * Base class for creating plugin settings tabs in Obsidian.
  * Provides a method for binding value components to plugin settings and handling changes.
@@ -57,23 +60,23 @@ export declare abstract class PluginSettingsTabBase<TPlugin extends PluginBase<a
      * @typeParam UIValue - The type of the value of the UI component.
      * @typeParam TValueComponent - The type of the value component.
      * @param valueComponent - The value component to bind.
-     * @param property - The property of the plugin settings to bind to.
+     * @param propertyName - The property of the plugin settings to bind to.
      * @param options - The options for binding the value component.
      * @returns The value component.
      */
-    bind<UIValue, TValueComponent>(valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>, property: ConditionalKeys<ExtractPluginSettings<TPlugin>, UIValue>, options?: BindOptions): TValueComponent;
+    bind<UIValue, TValueComponent>(valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>, propertyName: ConditionalKeys<ExtractPluginSettings<TPlugin>, UIValue>, options?: BindOptions<UIValue>): TValueComponent;
     /**
      * 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 Property - The property of the plugin settings to bind to.
+     * @typeParam PropertyName - The property name of the plugin settings to bind to.
      * @param valueComponent - The value component to bind.
-     * @param property - The property of the plugin settings to bind to.
+     * @param propertyName - The property name of the plugin settings to bind to.
      * @param options - The options for binding the value component.
      * @returns The value component.
      */
-    bind<UIValue, TValueComponent, Property extends StringKeys<ExtractPluginSettings<TPlugin>>>(valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>, property: Property, options: BindOptionsExtended<ExtractPluginSettings<TPlugin>, UIValue, Property>): TValueComponent;
+    bind<UIValue, TValueComponent, PropertyName extends StringKeys<ExtractPluginSettings<TPlugin>>>(valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>, propertyName: PropertyName, options: BindOptionsExtended<ExtractPluginSettings<TPlugin>, UIValue, PropertyName>): TValueComponent;
     hide(): void;
 }
 export {};