obsidian-dev-utils 24.1.1 → 24.2.0

package/dist/lib/esm/obsidian/Plugin/PluginSettingsManagerBase.d.mts

@@ -5,11 +5,11 @@
  */
 import type { App } from 'obsidian';
 import type { Promisable, ReadonlyDeep } from 'type-fest';
+import type { GenericObject } from '../../Object.mjs';
 import type { Transformer } from '../../Transformers/Transformer.mjs';
 import type { MaybeReturn, StringKeys } from '../../Type.mjs';
-import type { ExtractPlugin, ExtractPluginSettings, PluginTypesBase } from './PluginTypesBase.mjs';
-type PropertySetter = (value: unknown) => void;
-type Validator<T> = (value: T) => Promisable<MaybeReturn<string>>;
+import type { ExtractPlugin, ExtractPluginSettings, ExtractPluginSettingsPropertyNames, PluginTypesBase } from './PluginTypesBase.mjs';
+type Validator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (value: PluginSettings[PropertyName], settings: PluginSettings) => Promisable<MaybeReturn<string>>;
 /**
  * Base class for managing plugin settings.
  *
@@ -36,13 +36,22 @@ export declare abstract class PluginSettingsManagerBase<PluginTypes extends Plug
      * @returns A {@link Promise} that resolves when the settings are saved.
      */
     editAndSave(editor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>, context?: unknown): Promise<void>;
+    /**
+     * Ensures the settings are safe.
+     *
+     * It runs validation for each property and sets the default value if the validation fails.
+     *
+     * @param settings - The settings.
+     * @returns A {@link Promise} that resolves when the settings are safe.
+     */
+    ensureSafe(settings: ExtractPluginSettings<PluginTypes>): Promise<void>;
     /**
      * Gets a property of the plugin settings.
      *
      * @param propertyName - The name of the property.
      * @returns The property.
      */
-    getProperty<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(propertyName: PropertyName): PluginSettingsProperty<ExtractPluginSettings<PluginTypes>[PropertyName]>;
+    getProperty<PropertyName extends ExtractPluginSettingsPropertyNames<PluginTypes>>(propertyName: PropertyName): PluginSettingsProperty<ExtractPluginSettings<PluginTypes>, PropertyName>;
     /**
      * Loads the plugin settings from the file.
      *
@@ -69,20 +78,20 @@ export declare abstract class PluginSettingsManagerBase<PluginTypes extends Plug
      *
      * @param _record - The record.
      */
-    protected onLoadRecord(_record: Record<string, unknown>): Promise<void>;
+    protected onLoadRecord(_record: GenericObject): Promise<void>;
     /**
      * Called when the plugin settings are saving.
      *
      * @param _record - The record.
      */
-    protected onSavingRecord(_record: Record<string, unknown>): Promise<void>;
+    protected onSavingRecord(_record: GenericObject): Promise<void>;
     /**
      * Registers a validator for a property.
      *
      * @param propertyName - The name of the property.
      * @param validator - The validator.
      */
-    protected registerValidator<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(propertyName: PropertyName, validator: Validator<ExtractPluginSettings<PluginTypes>[PropertyName]>): void;
+    protected registerValidator<PropertyName extends ExtractPluginSettingsPropertyNames<PluginTypes>>(propertyName: PropertyName, validator: Validator<ExtractPluginSettings<PluginTypes>, PropertyName>): void;
     /**
      * Registers the validators.
      *
@@ -98,29 +107,29 @@ export declare abstract class PluginSettingsManagerBase<PluginTypes extends Plug
  *
  * @typeParam T - The type of the property.
  */
-export declare class PluginSettingsProperty<T> {
+export declare class PluginSettingsProperty<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> {
     private readonly propertyName;
-    readonly defaultValue: T;
+    private readonly currentSettings;
     private readonly validator;
-    private readonly propertySetter;
+    readonly defaultValue: typeof this.PropertyType;
     /**
      * The current value of the property.
      *
      * @returns The current value.
      */
-    get currentValue(): T;
+    get currentValue(): typeof this.PropertyType;
     /**
      * The last saved value of the property.
      *
      * @returns The last saved value.
      */
-    get lastSavedValue(): T;
+    get lastSavedValue(): typeof this.PropertyType;
     /**
      * The safe value of the property.
      *
      * @returns The safe value.
      */
-    get safeValue(): T;
+    get safeValue(): typeof this.PropertyType;
     /**
      * The validation message of the property.
      *
@@ -130,15 +139,16 @@ export declare class PluginSettingsProperty<T> {
     private _currentValue;
     private _lastSavedValue;
     private _validationMessage;
+    private PropertyType;
+    private get currentSettingsRecord();
     /**
      * Creates a new plugin settings property.
      *
      * @param propertyName - The name of the property.
-     * @param defaultValue - The default value of the property.
+     * @param currentSettings - The current settings.
      * @param validator - The validator of the property.
-     * @param propertySetter - The property setter of the property.
      */
-    constructor(propertyName: string, defaultValue: T, validator: Validator<T>, propertySetter: PropertySetter);
+    constructor(propertyName: StringKeys<PluginSettings>, currentSettings: PluginSettings, validator: Validator<PluginSettings, PropertyName>);
     /**
      * Resets the current value of the property to the default value.
      */
@@ -160,13 +170,14 @@ export declare class PluginSettingsProperty<T> {
      *
      * @param value - The value to set.
      */
-    setValue(value: T): void;
+    setValue(value: typeof this.PropertyType): void;
     /**
      * Validates the current value of the property.
      *
-     * @returns A {@link Promise} that resolves when the validation is complete.
+     * @param settings - The settings to validate. If not provided, the current settings will be used.
+     * @returns A {@link Promise} that resolves to the validation message.
      */
-    validate(): Promise<void>;
+    validate(settings?: PluginSettings): Promise<string>;
     private showWarning;
 }
 export {};

package/dist/lib/esm/obsidian/Plugin/PluginSettingsManagerBase.mjs

@@ -48,7 +48,9 @@ class EditableSettingsProxyHandler extends ProxyHandlerBase {
       return true;
     }
     property.setValue(value);
-    this.validationPromise = this.validationPromise.then(() => property.validate());
+    this.validationPromise = this.validationPromise.then(async () => {
+      await property.validate();
+    });
     return true;
   }
   getPropertyValue(property) {
@@ -84,15 +86,10 @@ class PluginSettingsManagerBase {
     this.currentSettings = this.createDefaultSettings();
     this.registerValidators();
     this.properties = new PropertiesMap();
-    const record = this.currentSettings;
     for (const propertyName of getAllKeys(this.currentSettings)) {
-      let propertySetter2 = function(value) {
-        record[propertyName] = value;
-      };
-      var propertySetter = propertySetter2;
       this.properties.set(
         propertyName,
-        new PluginSettingsProperty(propertyName, this.currentSettings[propertyName], this.validators.get(propertyName) ?? noop, propertySetter2)
+        new PluginSettingsProperty(propertyName, this.currentSettings, this.validators.get(propertyName) ?? noop)
       );
     }
     this.validators.clear();
@@ -102,7 +99,6 @@ class PluginSettingsManagerBase {
   safeSettings;
   currentSettings;
   properties;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   validators = /* @__PURE__ */ new Map();
   /**
    * Edits the plugin settings and saves them.
@@ -117,6 +113,24 @@ class PluginSettingsManagerBase {
     await editableSettings.validationPromise;
     await this.saveToFile(context);
   }
+  /**
+   * Ensures the settings are safe.
+   *
+   * It runs validation for each property and sets the default value if the validation fails.
+   *
+   * @param settings - The settings.
+   * @returns A {@link Promise} that resolves when the settings are safe.
+   */
+  async ensureSafe(settings) {
+    const record = settings;
+    for (const propertyName of getAllKeys(settings)) {
+      const property = this.getProperty(propertyName);
+      const validationMessage = await property.validate(settings);
+      if (validationMessage) {
+        record[propertyName] = property.defaultValue;
+      }
+    }
+  }
   /**
    * Gets a property of the plugin settings.
    *
@@ -264,18 +278,19 @@ class PluginSettingsProperty {
    * Creates a new plugin settings property.
    *
    * @param propertyName - The name of the property.
-   * @param defaultValue - The default value of the property.
+   * @param currentSettings - The current settings.
    * @param validator - The validator of the property.
-   * @param propertySetter - The property setter of the property.
    */
-  constructor(propertyName, defaultValue, validator, propertySetter) {
+  constructor(propertyName, currentSettings, validator) {
     this.propertyName = propertyName;
-    this.defaultValue = defaultValue;
+    this.currentSettings = currentSettings;
     this.validator = validator;
-    this.propertySetter = propertySetter;
-    this._lastSavedValue = defaultValue;
-    this._currentValue = defaultValue;
+    const record = currentSettings;
+    this.defaultValue = record[propertyName];
+    this._lastSavedValue = this.defaultValue;
+    this._currentValue = this.defaultValue;
   }
+  defaultValue;
   /**
    * The current value of the property.
    *
@@ -311,6 +326,9 @@ class PluginSettingsProperty {
   _currentValue;
   _lastSavedValue;
   _validationMessage = "";
+  get currentSettingsRecord() {
+    return this.currentSettings;
+  }
   /**
    * Resets the current value of the property to the default value.
    */
@@ -346,24 +364,33 @@ class PluginSettingsProperty {
    */
   setValue(value) {
     this._currentValue = value;
-    this.propertySetter(value);
+    this.currentSettingsRecord[this.propertyName] = value;
   }
   /**
    * Validates the current value of the property.
    *
-   * @returns A {@link Promise} that resolves when the validation is complete.
+   * @param settings - The settings to validate. If not provided, the current settings will be used.
+   * @returns A {@link Promise} that resolves to the validation message.
    */
-  async validate() {
+  async validate(settings) {
+    const isCurrent = settings === void 0;
+    settings ??= this.currentSettings;
+    const value = isCurrent ? this._currentValue : settings[this.propertyName];
+    let validationMessage;
     try {
-      this._validationMessage = await this.validator(this._currentValue) ?? "";
+      validationMessage = await this.validator(value, settings) ?? "";
     } catch (error) {
       console.error("Validation failed", {
         propertyName: this.propertyName,
-        value: this._currentValue
+        value
       }, error);
-      this._validationMessage = "Validation failed";
+      validationMessage = "Validation failed";
+    }
+    if (isCurrent) {
+      this._validationMessage = validationMessage;
+      this.showWarning(this._currentValue);
     }
-    this.showWarning(this._currentValue);
+    return validationMessage;
   }
   showWarning(value) {
     if (!this._validationMessage) {
@@ -381,4 +408,4 @@ export {
   PluginSettingsManagerBase,
   PluginSettingsProperty
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Plugin settings manager base class.\n */\n\nimport type { App } from 'obsidian';\nimport type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type { Transformer } from '../../Transformers/Transformer.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../Type.ts';\nimport type {\n  ExtractPlugin,\n  ExtractPluginSettings,\n  PluginTypesBase\n} from './PluginTypesBase.ts';\n\nimport {\n  noop,\n  noopAsync\n} from '../../Function.ts';\nimport { getAllKeys } from '../../Object.ts';\nimport { DateTransformer } from '../../Transformers/DateTransformer.ts';\nimport { DurationTransformer } from '../../Transformers/DurationTransformer.ts';\nimport { GroupTransformer } from '../../Transformers/GroupTransformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../Transformers/SkipPrivatePropertyTransformer.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer()\n]);\n\ntype PropertySetter = (value: unknown) => void;\n\ntype Validator<T> = (value: T) => Promisable<MaybeReturn<string>>;\n\nabstract class ProxyHandlerBase<PluginSettings extends object> implements ProxyHandler<PluginSettings> {\n  public constructor(protected readonly properties: PropertiesMap<PluginSettings>) {}\n\n  public get(target: PluginSettings, prop: string | symbol): unknown {\n    const record = target as Record<string | symbol, unknown>;\n    if (typeof prop !== 'string') {\n      return record[prop];\n    }\n\n    const property = this.properties.get(prop);\n    if (!property) {\n      return record[prop];\n    }\n\n    return this.getPropertyValue(property);\n  }\n\n  protected abstract getPropertyValue(property: PluginSettingsProperty<unknown>): unknown;\n}\n\nclass EditableSettingsProxyHandler<PluginSettings extends object> extends ProxyHandlerBase<PluginSettings> {\n  private validationPromise = Promise.resolve();\n  public set(target: PluginSettings, prop: string | symbol, value: unknown): boolean {\n    const record = target as Record<string | symbol, unknown>;\n    record[prop] = value;\n\n    if (typeof prop !== 'string') {\n      return true;\n    }\n\n    const property = this.properties.get(prop);\n    if (!property) {\n      return true;\n    }\n\n    property.setValue(value);\n    this.validationPromise = this.validationPromise.then(() => property.validate());\n    return true;\n  }\n\n  protected override getPropertyValue(property: PluginSettingsProperty<unknown>): unknown {\n    return property.currentValue;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nclass PropertiesMap<PluginSettings extends object> extends Map<string, PluginSettingsProperty<any>> {\n  public getTyped<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName): PluginSettingsProperty<PluginSettings[PropertyName]> {\n    const property = super.get(propertyName);\n    if (!property) {\n      throw new Error(`Property ${String(propertyName)} not found`);\n    }\n\n    return property as PluginSettingsProperty<PluginSettings[PropertyName]>;\n  }\n\n  public setTyped<PropertyName extends StringKeys<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettingsProperty<PluginSettings[PropertyName]>\n  ): this {\n    return super.set(propertyName, value);\n  }\n}\n\nclass SafeSettingsProxyHandler<PluginSettings extends object> extends ProxyHandlerBase<PluginSettings> {\n  protected override getPropertyValue(property: PluginSettingsProperty<unknown>): unknown {\n    return property.safeValue;\n  }\n}\n\n/**\n * Base class for managing plugin settings.\n *\n * @typeParam PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginSettingsManagerBase<PluginTypes extends PluginTypesBase> {\n  public readonly app: App;\n  public readonly safeSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n\n  private readonly currentSettings: ExtractPluginSettings<PluginTypes>;\n  private readonly properties: PropertiesMap<ExtractPluginSettings<PluginTypes>>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private readonly validators: Map<string, Validator<any>> = new Map<string, Validator<any>>();\n\n  /**\n   * Creates a new plugin settings manager.\n   *\n   * @param plugin - The plugin.\n   */\n  public constructor(public readonly plugin: ExtractPlugin<PluginTypes>) {\n    this.app = plugin.app;\n    this.currentSettings = this.createDefaultSettings();\n\n    this.registerValidators();\n\n    this.properties = new PropertiesMap<ExtractPluginSettings<PluginTypes>>();\n\n    const record = this.currentSettings as Record<string, unknown>;\n\n    for (const propertyName of getAllKeys(this.currentSettings)) {\n      function propertySetter(value: unknown): void {\n        record[propertyName] = value;\n      }\n\n      this.properties.set(\n        propertyName,\n        new PluginSettingsProperty(propertyName, this.currentSettings[propertyName], this.validators.get(propertyName) ?? noop, propertySetter)\n      );\n    }\n\n    this.validators.clear();\n\n    this.safeSettings = new Proxy(this.currentSettings, new SafeSettingsProxyHandler<ExtractPluginSettings<PluginTypes>>(this.properties)) as ReadonlyDeep<\n      ExtractPluginSettings<PluginTypes>\n    >;\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param editor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(editor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>, context?: unknown): Promise<void> {\n    const editableSettings = new Proxy(this.currentSettings, new EditableSettingsProxyHandler<ExtractPluginSettings<PluginTypes>>(this.properties)) as {\n      validationPromise: Promise<void>;\n    } & ExtractPluginSettings<PluginTypes>;\n    await editor(editableSettings);\n    await editableSettings.validationPromise;\n    await this.saveToFile(context);\n  }\n\n  /**\n   * Gets a property of the plugin settings.\n   *\n   * @param propertyName - The name of the property.\n   * @returns The property.\n   */\n  public getProperty<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(\n    propertyName: PropertyName\n  ): PluginSettingsProperty<ExtractPluginSettings<PluginTypes>[PropertyName]> {\n    return this.properties.getTyped(propertyName);\n  }\n\n  /**\n   * Loads the plugin settings from the file.\n   *\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  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    for (const property of this.properties.values()) {\n      property.reset();\n    }\n\n    const data = await this.plugin.loadData() as unknown;\n\n    if (data === undefined || data === null) {\n      return;\n    }\n\n    if (typeof data !== 'object' || Array.isArray(data)) {\n      const type = Array.isArray(data) ? 'Array' : typeof data;\n      console.error(`Invalid data type. Expected Object, got: ${type}`);\n      return;\n    }\n\n    let record = data as Record<string, unknown>;\n    const originalJson = JSON.stringify(record);\n    record = this.getTransformer().transformObjectRecursively(record);\n    await this.onLoadRecord(record);\n\n    const propertiesToSave: PluginSettingsProperty<unknown>[] = [];\n\n    for (const [propertyName, value] of Object.entries(record)) {\n      const property = this.properties.get(propertyName);\n      if (!property) {\n        console.warn(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof property.defaultValue) {\n        console.warn(\n          'Possible invalid value type read from config file. It might lead to an unexpected behavior of the plugin. There is also a chance it is a false-negative warning, as we are unable to determine the exact type of the value in runtime.',\n          {\n            defaultValue: property.defaultValue as unknown,\n            propertyName,\n            value\n          }\n        );\n      }\n\n      property.setValue(value);\n      propertiesToSave.push(property);\n    }\n\n    for (const property of propertiesToSave) {\n      await property.validate();\n      property.save();\n    }\n\n    const newJson = JSON.stringify(await this.prepareRecordToSave());\n\n    if (newJson !== originalJson) {\n      await this.saveToFileImpl();\n    }\n\n    await this.plugin.onLoadSettings(this.getSavedSettings(), isInitialLoad);\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @param context - The context of the save to file operation.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async saveToFile(context?: unknown): Promise<void> {\n    const oldSettings = this.getSavedSettings();\n\n    let hasChanges = false;\n\n    for (const property of this.properties.values()) {\n      hasChanges ||= property.save();\n    }\n\n    if (!hasChanges) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings, context);\n  }\n\n  protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;\n\n  /**\n   * Gets the transformer.\n   *\n   * @returns The transformer.\n   */\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  /**\n   * Called when the plugin settings are loaded.\n   *\n   * @param _record - The record.\n   */\n  protected async onLoadRecord(_record: Record<string, unknown>): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings are saving.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: Record<string, unknown>): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  protected registerValidator<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(\n    propertyName: PropertyName,\n    validator: Validator<ExtractPluginSettings<PluginTypes>[PropertyName]>\n  ): void {\n    this.validators.set(propertyName, validator);\n  }\n\n  /**\n   * Registers the validators.\n   *\n   * This method can be overridden by subclasses to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private getSavedSettings(): ExtractPluginSettings<PluginTypes> {\n    const savedSettings: Record<string, unknown> = {};\n    for (const [propertyName, property] of this.properties.entries()) {\n      savedSettings[propertyName] = property.lastSavedValue as\n        | ExtractPluginSettings<PluginTypes>[StringKeys<ExtractPluginSettings<PluginTypes>>]\n        | undefined;\n    }\n    const proto = Object.getPrototypeOf(this.currentSettings) as object;\n    Object.setPrototypeOf(savedSettings, proto);\n\n    return savedSettings as ExtractPluginSettings<PluginTypes>;\n  }\n\n  private async prepareRecordToSave(): Promise<Record<string, unknown>> {\n    const settings: Record<string, unknown> = {};\n    for (const [propertyName, property] of this.properties.entries()) {\n      settings[propertyName] = property.currentValue as unknown;\n    }\n\n    await this.onSavingRecord(settings);\n\n    return this.getTransformer().transformObjectRecursively(settings);\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.plugin.saveData(await this.prepareRecordToSave());\n  }\n}\n\n/**\n * A property of a plugin settings.\n *\n * @typeParam T - The type of the property.\n */\nexport class PluginSettingsProperty<T> {\n  /**\n   * The current value of the property.\n   *\n   * @returns The current value.\n   */\n  public get currentValue(): T {\n    return this._currentValue;\n  }\n\n  /**\n   * The last saved value of the property.\n   *\n   * @returns The last saved value.\n   */\n  public get lastSavedValue(): T {\n    return this._lastSavedValue;\n  }\n\n  /**\n   * The safe value of the property.\n   *\n   * @returns The safe value.\n   */\n  public get safeValue(): T {\n    return this._validationMessage ? this.defaultValue : this._currentValue;\n  }\n\n  /**\n   * The validation message of the property.\n   *\n   * @returns The validation message.\n   */\n  public get validationMessage(): string {\n    return this._validationMessage;\n  }\n\n  private _currentValue: T;\n\n  private _lastSavedValue: T;\n\n  private _validationMessage = '';\n\n  /**\n   * Creates a new plugin settings property.\n   *\n   * @param propertyName - The name of the property.\n   * @param defaultValue - The default value of the property.\n   * @param validator - The validator of the property.\n   * @param propertySetter - The property setter of the property.\n   */\n  public constructor(\n    private readonly propertyName: string,\n    public readonly defaultValue: T,\n    private readonly validator: Validator<T>,\n    private readonly propertySetter: PropertySetter\n  ) {\n    this._lastSavedValue = defaultValue;\n    this._currentValue = defaultValue;\n  }\n\n  /**\n   * Resets the current value of the property to the default value.\n   */\n  public reset(): void {\n    this._currentValue = this.defaultValue;\n    this._validationMessage = '';\n  }\n\n  /**\n   * Saves the current value of the property.\n   *\n   * @returns `true` if the value was changed, `false` otherwise.\n   */\n  public save(): boolean {\n    if (this._lastSavedValue === this._currentValue) {\n      return false;\n    }\n\n    this._lastSavedValue = this._currentValue;\n    return true;\n  }\n\n  /**\n   * Sets the validation message of the property.\n   *\n   * @param validationMessage - The validation message.\n   */\n  public setValidationMessage(validationMessage: string): void {\n    this._validationMessage = validationMessage;\n    this.showWarning();\n  }\n\n  /**\n   * Sets the current value of the property.\n   *\n   * @param value - The value to set.\n   */\n  public setValue(value: T): void {\n    this._currentValue = value;\n    this.propertySetter(value);\n  }\n\n  /**\n   * Validates the current value of the property.\n   *\n   * @returns A {@link Promise} that resolves when the validation is complete.\n   */\n  public async validate(): Promise<void> {\n    try {\n      this._validationMessage = (await this.validator(this._currentValue) as string | undefined) ?? '';\n    } catch (error) {\n      console.error('Validation failed', {\n        propertyName: this.propertyName,\n        value: this._currentValue\n      }, error);\n      this._validationMessage = 'Validation failed';\n    }\n    this.showWarning(this._currentValue);\n  }\n\n  private showWarning(value?: T): void {\n    if (!this._validationMessage) {\n      return;\n    }\n\n    console.warn(`Could not set plugin setting: ${this.propertyName}. Using default value instead.`, {\n      defaultValue: this.defaultValue,\n      propertyName: this.propertyName,\n      validationMessage: this._validationMessage,\n      value\n    });\n  }\n}\n"],
  "mappings": "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",
  "names": ["propertySetter"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Plugin settings manager base class.\n */\n\nimport type { App } from 'obsidian';\nimport type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type { GenericObject } from '../../Object.ts';\nimport type { Transformer } from '../../Transformers/Transformer.ts';\nimport type {\n  MaybeReturn,\n  PropertyValues,\n  StringKeys\n} from '../../Type.ts';\nimport type {\n  ExtractPlugin,\n  ExtractPluginSettings,\n  ExtractPluginSettingsPropertyNames,\n  ExtractPluginSettingsPropertyValues,\n  PluginTypesBase\n} from './PluginTypesBase.ts';\n\nimport {\n  noop,\n  noopAsync\n} from '../../Function.ts';\nimport { getAllKeys } from '../../Object.ts';\nimport { DateTransformer } from '../../Transformers/DateTransformer.ts';\nimport { DurationTransformer } from '../../Transformers/DurationTransformer.ts';\nimport { GroupTransformer } from '../../Transformers/GroupTransformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../Transformers/SkipPrivatePropertyTransformer.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer()\n]);\n\ntype Validator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<string>>;\n\nabstract class ProxyHandlerBase<PluginSettings extends object> implements ProxyHandler<PluginSettings> {\n  public constructor(protected readonly properties: PropertiesMap<PluginSettings>) {}\n\n  public get(target: PluginSettings, prop: string | symbol): unknown {\n    const record = target as Record<string | symbol, unknown>;\n    if (typeof prop !== 'string') {\n      return record[prop];\n    }\n\n    const property = this.properties.get(prop);\n    if (!property) {\n      return record[prop];\n    }\n\n    return this.getPropertyValue(property);\n  }\n\n  protected abstract getPropertyValue(property: PluginSettingsProperty<PluginSettings>): unknown;\n}\n\nclass EditableSettingsProxyHandler<PluginSettings extends object> extends ProxyHandlerBase<PluginSettings> {\n  private validationPromise = Promise.resolve();\n  public set(target: PluginSettings, prop: string | symbol, value: unknown): boolean {\n    const record = target as Record<string | symbol, unknown>;\n    record[prop] = value;\n\n    if (typeof prop !== 'string') {\n      return true;\n    }\n\n    const property = this.properties.get(prop);\n    if (!property) {\n      return true;\n    }\n\n    property.setValue(value as PropertyValues<PluginSettings>);\n    this.validationPromise = this.validationPromise.then(async () => {\n      await property.validate();\n    });\n    return true;\n  }\n\n  protected override getPropertyValue(property: PluginSettingsProperty<PluginSettings>): unknown {\n    return property.currentValue;\n  }\n}\n\nclass PropertiesMap<PluginSettings extends object> extends Map<string, PluginSettingsProperty<PluginSettings, StringKeys<PluginSettings>>> {\n  public getTyped<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName): PluginSettingsProperty<PluginSettings, PropertyName> {\n    const property = super.get(propertyName);\n    if (!property) {\n      throw new Error(`Property ${String(propertyName)} not found`);\n    }\n\n    return property as unknown as PluginSettingsProperty<PluginSettings, PropertyName>;\n  }\n\n  public setTyped<PropertyName extends StringKeys<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettingsProperty<PluginSettings, PropertyName>\n  ): this {\n    return super.set(propertyName, value as unknown as PluginSettingsProperty<PluginSettings, StringKeys<PluginSettings>>);\n  }\n}\n\nclass SafeSettingsProxyHandler<PluginSettings extends object> extends ProxyHandlerBase<PluginSettings> {\n  protected override getPropertyValue(property: PluginSettingsProperty<PluginSettings>): unknown {\n    return property.safeValue;\n  }\n}\n\n/**\n * Base class for managing plugin settings.\n *\n * @typeParam PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginSettingsManagerBase<PluginTypes extends PluginTypesBase> {\n  public readonly app: App;\n  public readonly safeSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n\n  private readonly currentSettings: ExtractPluginSettings<PluginTypes>;\n  private readonly properties: PropertiesMap<ExtractPluginSettings<PluginTypes>>;\n  private readonly validators: Map<string, Validator<ExtractPluginSettings<PluginTypes>>> = new Map<\n    string,\n    Validator<ExtractPluginSettings<PluginTypes>>\n  >();\n\n  /**\n   * Creates a new plugin settings manager.\n   *\n   * @param plugin - The plugin.\n   */\n  public constructor(public readonly plugin: ExtractPlugin<PluginTypes>) {\n    this.app = plugin.app;\n    this.currentSettings = this.createDefaultSettings();\n\n    this.registerValidators();\n\n    this.properties = new PropertiesMap<ExtractPluginSettings<PluginTypes>>();\n\n    for (const propertyName of getAllKeys(this.currentSettings)) {\n      this.properties.set(\n        propertyName,\n        new PluginSettingsProperty(propertyName, this.currentSettings, this.validators.get(propertyName) ?? noop)\n      );\n    }\n\n    this.validators.clear();\n\n    this.safeSettings = new Proxy(this.currentSettings, new SafeSettingsProxyHandler<ExtractPluginSettings<PluginTypes>>(this.properties)) as ReadonlyDeep<\n      ExtractPluginSettings<PluginTypes>\n    >;\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param editor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(editor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>, context?: unknown): Promise<void> {\n    const editableSettings = new Proxy(this.currentSettings, new EditableSettingsProxyHandler<ExtractPluginSettings<PluginTypes>>(this.properties)) as {\n      validationPromise: Promise<void>;\n    } & ExtractPluginSettings<PluginTypes>;\n    await editor(editableSettings);\n    await editableSettings.validationPromise;\n    await this.saveToFile(context);\n  }\n\n  /**\n   * Ensures the settings are safe.\n   *\n   * It runs validation for each property and sets the default value if the validation fails.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves when the settings are safe.\n   */\n  public async ensureSafe(settings: ExtractPluginSettings<PluginTypes>): Promise<void> {\n    const record = settings as GenericObject;\n    for (const propertyName of getAllKeys(settings)) {\n      const property = this.getProperty(propertyName);\n      const validationMessage = await property.validate(settings);\n      if (validationMessage) {\n        record[propertyName] = property.defaultValue;\n      }\n    }\n  }\n\n  /**\n   * Gets a property of the plugin settings.\n   *\n   * @param propertyName - The name of the property.\n   * @returns The property.\n   */\n  public getProperty<PropertyName extends ExtractPluginSettingsPropertyNames<PluginTypes>>(\n    propertyName: PropertyName\n  ): PluginSettingsProperty<ExtractPluginSettings<PluginTypes>, PropertyName> {\n    return this.properties.getTyped(propertyName);\n  }\n\n  /**\n   * Loads the plugin settings from the file.\n   *\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  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    type PluginSettings = ExtractPluginSettings<PluginTypes>;\n\n    for (const property of this.properties.values()) {\n      property.reset();\n    }\n\n    const data = await this.plugin.loadData() as unknown;\n\n    if (data === undefined || data === null) {\n      return;\n    }\n\n    if (typeof data !== 'object' || Array.isArray(data)) {\n      const type = Array.isArray(data) ? 'Array' : typeof data;\n      console.error(`Invalid data type. Expected Object, got: ${type}`);\n      return;\n    }\n\n    let record = data as GenericObject;\n    const originalJson = JSON.stringify(record);\n    record = this.getTransformer().transformObjectRecursively(record);\n    await this.onLoadRecord(record);\n\n    const propertiesToSave: PluginSettingsProperty<PluginSettings>[] = [];\n\n    for (const [propertyName, value] of Object.entries(record)) {\n      const property = this.properties.get(propertyName);\n      if (!property) {\n        console.warn(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof property.defaultValue) {\n        console.warn(\n          'Possible invalid value type read from config file. It might lead to an unexpected behavior of the plugin. There is also a chance it is a false-negative warning, as we are unable to determine the exact type of the value in runtime.',\n          {\n            defaultValue: property.defaultValue,\n            propertyName,\n            value\n          }\n        );\n      }\n\n      property.setValue(value as PropertyValues<PluginSettings>);\n      propertiesToSave.push(property);\n    }\n\n    for (const property of propertiesToSave) {\n      await property.validate();\n      property.save();\n    }\n\n    const newJson = JSON.stringify(await this.prepareRecordToSave());\n\n    if (newJson !== originalJson) {\n      await this.saveToFileImpl();\n    }\n\n    await this.plugin.onLoadSettings(this.getSavedSettings(), isInitialLoad);\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @param context - The context of the save to file operation.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async saveToFile(context?: unknown): Promise<void> {\n    const oldSettings = this.getSavedSettings();\n\n    let hasChanges = false;\n\n    for (const property of this.properties.values()) {\n      hasChanges ||= property.save();\n    }\n\n    if (!hasChanges) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings, context);\n  }\n\n  protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;\n\n  /**\n   * Gets the transformer.\n   *\n   * @returns The transformer.\n   */\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  /**\n   * Called when the plugin settings are loaded.\n   *\n   * @param _record - The record.\n   */\n  protected async onLoadRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings are saving.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  protected registerValidator<PropertyName extends ExtractPluginSettingsPropertyNames<PluginTypes>>(\n    propertyName: PropertyName,\n    validator: Validator<ExtractPluginSettings<PluginTypes>, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as Validator<ExtractPluginSettings<PluginTypes>>);\n  }\n\n  /**\n   * Registers the validators.\n   *\n   * This method can be overridden by subclasses to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private getSavedSettings(): ExtractPluginSettings<PluginTypes> {\n    const savedSettings: GenericObject = {};\n    for (const [propertyName, property] of this.properties.entries()) {\n      savedSettings[propertyName] = property.lastSavedValue as\n        | ExtractPluginSettingsPropertyValues<PluginTypes>\n        | undefined;\n    }\n    const proto = Object.getPrototypeOf(this.currentSettings) as object;\n    Object.setPrototypeOf(savedSettings, proto);\n\n    return savedSettings as ExtractPluginSettings<PluginTypes>;\n  }\n\n  private async prepareRecordToSave(): Promise<GenericObject> {\n    const settings: GenericObject = {};\n    for (const [propertyName, property] of this.properties.entries()) {\n      settings[propertyName] = property.currentValue;\n    }\n\n    await this.onSavingRecord(settings);\n\n    return this.getTransformer().transformObjectRecursively(settings);\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.plugin.saveData(await this.prepareRecordToSave());\n  }\n}\n\n/**\n * A property of a plugin settings.\n *\n * @typeParam T - The type of the property.\n */\nexport class PluginSettingsProperty<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> {\n  public readonly defaultValue: typeof this.PropertyType;\n\n  /**\n   * The current value of the property.\n   *\n   * @returns The current value.\n   */\n  public get currentValue(): typeof this.PropertyType {\n    return this._currentValue;\n  }\n\n  /**\n   * The last saved value of the property.\n   *\n   * @returns The last saved value.\n   */\n  public get lastSavedValue(): typeof this.PropertyType {\n    return this._lastSavedValue;\n  }\n\n  /**\n   * The safe value of the property.\n   *\n   * @returns The safe value.\n   */\n  public get safeValue(): typeof this.PropertyType {\n    return this._validationMessage ? this.defaultValue : this._currentValue;\n  }\n\n  /**\n   * The validation message of the property.\n   *\n   * @returns The validation message.\n   */\n  public get validationMessage(): string {\n    return this._validationMessage;\n  }\n\n  private _currentValue: typeof this.PropertyType;\n\n  private _lastSavedValue: typeof this.PropertyType;\n\n  private _validationMessage = '';\n\n  declare private PropertyType: PluginSettings[PropertyName];\n\n  private get currentSettingsRecord(): GenericObject {\n    return this.currentSettings as GenericObject;\n  }\n\n  /**\n   * Creates a new plugin settings property.\n   *\n   * @param propertyName - The name of the property.\n   * @param currentSettings - The current settings.\n   * @param validator - The validator of the property.\n   */\n  public constructor(\n    private readonly propertyName: StringKeys<PluginSettings>,\n    private readonly currentSettings: PluginSettings,\n    private readonly validator: Validator<PluginSettings, PropertyName>\n  ) {\n    const record = currentSettings as GenericObject;\n    this.defaultValue = record[propertyName] as typeof this.PropertyType;\n    this._lastSavedValue = this.defaultValue;\n    this._currentValue = this.defaultValue;\n  }\n\n  /**\n   * Resets the current value of the property to the default value.\n   */\n  public reset(): void {\n    this._currentValue = this.defaultValue;\n    this._validationMessage = '';\n  }\n\n  /**\n   * Saves the current value of the property.\n   *\n   * @returns `true` if the value was changed, `false` otherwise.\n   */\n  public save(): boolean {\n    if (this._lastSavedValue === this._currentValue) {\n      return false;\n    }\n\n    this._lastSavedValue = this._currentValue;\n    return true;\n  }\n\n  /**\n   * Sets the validation message of the property.\n   *\n   * @param validationMessage - The validation message.\n   */\n  public setValidationMessage(validationMessage: string): void {\n    this._validationMessage = validationMessage;\n    this.showWarning();\n  }\n\n  /**\n   * Sets the current value of the property.\n   *\n   * @param value - The value to set.\n   */\n  public setValue(value: typeof this.PropertyType): void {\n    this._currentValue = value;\n    this.currentSettingsRecord[this.propertyName] = value;\n  }\n\n  /**\n   * Validates the current value of the property.\n   *\n   * @param settings - The settings to validate. If not provided, the current settings will be used.\n   * @returns A {@link Promise} that resolves to the validation message.\n   */\n  public async validate(settings?: PluginSettings): Promise<string> {\n    const isCurrent = settings === undefined;\n    settings ??= this.currentSettings;\n    const value = isCurrent ? this._currentValue : settings[this.propertyName] as typeof this.PropertyType;\n\n    let validationMessage: string;\n    try {\n      validationMessage = (await this.validator(value, settings) as string | undefined) ?? '';\n    } catch (error) {\n      console.error('Validation failed', {\n        propertyName: this.propertyName,\n        value\n      }, error);\n      validationMessage = 'Validation failed';\n    }\n\n    if (isCurrent) {\n      this._validationMessage = validationMessage;\n      this.showWarning(this._currentValue);\n    }\n\n    return validationMessage;\n  }\n\n  private showWarning(value?: typeof this.PropertyType): void {\n    if (!this._validationMessage) {\n      return;\n    }\n\n    console.warn(`Could not set plugin setting: ${this.propertyName}. Using default value instead.`, {\n      defaultValue: this.defaultValue,\n      propertyName: this.propertyName,\n      validationMessage: this._validationMessage,\n      value\n    });\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/Plugin/PluginSettingsTabBase.mjs

@@ -148,4 +148,4 @@ class PluginSettingsTabBase extends PluginSettingTab {
 export {
   PluginSettingsTabBase
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsTabBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\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 { Debouncer } from 'obsidian';\nimport type {\n  ConditionalKeys,\n  Promisable\n} from 'type-fest';\n\nimport {\n  debounce,\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 { PluginSettingsProperty } from './PluginSettingsManagerBase.ts';\nimport type {\n  ExtractPlugin,\n  ExtractPluginSettings,\n  PluginTypesBase\n} from './PluginTypesBase.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} 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   *\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: PluginSettings[PropertyName]) => UIValue;\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 PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginSettingsTabBase<PluginTypes extends PluginTypesBase> extends 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 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\n  private saveSettingsDebounced: Debouncer<[], void>;\n\n  /**\n   * Creates a new plugin settings tab.\n   *\n   * @param plugin - The plugin.\n   */\n  public constructor(public override plugin: ExtractPlugin<PluginTypes>) {\n    super(plugin.app, plugin);\n    this.containerEl.addClass(CssClass.LibraryName, getPluginId(), CssClass.PluginSettingsTab);\n    this.saveSettingsDebounced = debounce(convertAsyncToSync(() => this.plugin.settingsManager.saveToFile()), this.saveSettingsDebounceTimeoutInMilliseconds);\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<PluginTypes>, 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<PluginTypes>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: PropertyName,\n    options: BindOptionsExtended<ExtractPluginSettings<PluginTypes>, 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<PluginTypes>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: PropertyName,\n    options?: BindOptions<ExtractPluginSettings<PluginTypes>[PropertyName]>\n  ): TValueComponent {\n    type PluginSettings = ExtractPluginSettings<PluginTypes>;\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: 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      const oldValue = property.currentValue;\n      let newValue: PropertyType | undefined = undefined;\n      if (textBasedComponent?.isEmpty() && optionsExt.shouldResetSettingWhenComponentIsEmpty) {\n        property.reset();\n        newValue = property.defaultValue;\n      } else {\n        const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);\n        if (isValidationMessageHolder(convertedValue)) {\n          property.setValidationMessage(convertedValue.validationMessage);\n        } else {\n          property.setValue(convertedValue);\n          await property.validate();\n          newValue = convertedValue;\n        }\n      }\n      updateValidatorElement();\n      if (newValue !== undefined) {\n        await optionsExt.onChanged(newValue, oldValue);\n      }\n      this.saveSettingsDebounced();\n    });\n\n    validatorElement?.addEventListener('focus', updateValidatorElement);\n    validatorElement?.addEventListener('blur', updateValidatorElement);\n\n    updateValidatorElement();\n    return valueComponent;\n\n    function updateValidatorElement(): 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  /**\n   * Renders the plugin settings tab.\n   */\n  public override display(): void {\n    this._isOpen = true;\n  }\n\n  /**\n   * Hides the plugin settings tab.\n   */\n  public override hide(): void {\n    super.hide();\n    this._isOpen = false;\n    this.saveSettingsDebounced.cancel();\n    invokeAsyncSafely(() => this.plugin.settingsManager.saveToFile());\n  }\n\n  /**\n   * Shows the plugin settings tab.\n   */\n  public show(): void {\n    this.app.setting.openTab(this);\n  }\n}\n"],
  "mappings": "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",
  "names": ["value"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsTabBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\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 { Debouncer } from 'obsidian';\nimport type {\n  ConditionalKeys,\n  Promisable\n} from 'type-fest';\n\nimport {\n  debounce,\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 { PluginSettingsProperty } from './PluginSettingsManagerBase.ts';\nimport type {\n  ExtractPlugin,\n  ExtractPluginSettings,\n  PluginTypesBase\n} from './PluginTypesBase.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} 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   *\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: PluginSettings[PropertyName]) => UIValue;\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 PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginSettingsTabBase<PluginTypes extends PluginTypesBase> extends 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 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\n  private saveSettingsDebounced: Debouncer<[], void>;\n\n  /**\n   * Creates a new plugin settings tab.\n   *\n   * @param plugin - The plugin.\n   */\n  public constructor(public override plugin: ExtractPlugin<PluginTypes>) {\n    super(plugin.app, plugin);\n    this.containerEl.addClass(CssClass.LibraryName, getPluginId(), CssClass.PluginSettingsTab);\n    this.saveSettingsDebounced = debounce(convertAsyncToSync(() => this.plugin.settingsManager.saveToFile()), this.saveSettingsDebounceTimeoutInMilliseconds);\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<PluginTypes>, 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<PluginTypes>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: PropertyName,\n    options: BindOptionsExtended<ExtractPluginSettings<PluginTypes>, 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<PluginTypes>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: PropertyName,\n    options?: BindOptions<ExtractPluginSettings<PluginTypes>[PropertyName]>\n  ): TValueComponent {\n    type PluginSettings = ExtractPluginSettings<PluginTypes>;\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: 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<PluginSettings, PropertyName>;\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      const oldValue = property.currentValue;\n      let newValue: PropertyType | undefined = undefined;\n      if (textBasedComponent?.isEmpty() && optionsExt.shouldResetSettingWhenComponentIsEmpty) {\n        property.reset();\n        newValue = property.defaultValue;\n      } else {\n        const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);\n        if (isValidationMessageHolder(convertedValue)) {\n          property.setValidationMessage(convertedValue.validationMessage);\n        } else {\n          property.setValue(convertedValue);\n          await property.validate();\n          newValue = convertedValue;\n        }\n      }\n      updateValidatorElement();\n      if (newValue !== undefined) {\n        await optionsExt.onChanged(newValue, oldValue);\n      }\n      this.saveSettingsDebounced();\n    });\n\n    validatorElement?.addEventListener('focus', updateValidatorElement);\n    validatorElement?.addEventListener('blur', updateValidatorElement);\n\n    updateValidatorElement();\n    return valueComponent;\n\n    function updateValidatorElement(): 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  /**\n   * Renders the plugin settings tab.\n   */\n  public override display(): void {\n    this._isOpen = true;\n  }\n\n  /**\n   * Hides the plugin settings tab.\n   */\n  public override hide(): void {\n    super.hide();\n    this._isOpen = false;\n    this.saveSettingsDebounced.cancel();\n    invokeAsyncSafely(() => this.plugin.settingsManager.saveToFile());\n  }\n\n  /**\n   * Shows the plugin settings tab.\n   */\n  public show(): void {\n    this.app.setting.openTab(this);\n  }\n}\n"],
  "mappings": "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",
  "names": ["value"]
}


package/dist/lib/esm/obsidian/Plugin/PluginTypesBase.d.mts

@@ -3,6 +3,7 @@
  *
  * Types helpers for plugin types.
  */
+import type { PropertyValues, StringKeys } from '../../Type.mjs';
 import type { PluginBase } from './PluginBase.mjs';
 import type { PluginSettingsManagerBase } from './PluginSettingsManagerBase.mjs';
 import type { PluginSettingsTabBase } from './PluginSettingsTabBase.mjs';
@@ -24,6 +25,18 @@ export type ExtractPluginSettings<PluginTypes extends PluginTypesBase> = PluginT
  * @typeParam PluginTypes - The plugin types.
  */
 export type ExtractPluginSettingsManager<PluginTypes extends PluginTypesBase> = PluginTypes['pluginSettingsManager'];
+/**
+ * Extracts the plugin settings property names from the plugin types.
+ *
+ * @typeParam PluginTypes - The plugin types.
+ */
+export type ExtractPluginSettingsPropertyNames<PluginTypes extends PluginTypesBase> = StringKeys<ExtractPluginSettings<PluginTypes>>;
+/**
+ * Extracts the plugin settings property values from the plugin types.
+ *
+ * @typeParam PluginTypes - The plugin types.
+ */
+export type ExtractPluginSettingsPropertyValues<PluginTypes extends PluginTypesBase> = PropertyValues<ExtractPluginSettings<PluginTypes>>;
 /**
  * Extracts the plugin settings tab from the plugin types.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "24.1.1",
+  "version": "24.2.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development",
   "keywords": [
     "obsidian"
@@ -439,8 +439,8 @@
     "@types/pug": "^2.0.10",
     "@types/react": "^19.1.0",
     "@types/shell-quote": "^1.7.5",
-    "@typescript-eslint/eslint-plugin": "^8.29.0",
-    "@typescript-eslint/parser": "^8.29.0",
+    "@typescript-eslint/eslint-plugin": "^8.29.1",
+    "@typescript-eslint/parser": "^8.29.1",
     "better-typescript-lib": "^2.11.0",
     "commander": "^13.1.0",
     "compare-versions": "^6.1.1",
@@ -467,7 +467,7 @@
     "monkey-around": "^3.0.0",
     "npm-run-all": "^4.1.5",
     "obsidian": "^1.8.7",
-    "obsidian-typings": "^2.41.4",
+    "obsidian-typings": "^2.42.0",
     "path-browserify": "^1.0.1",
     "postcss": "^8.5.3",
     "postcss-modules": "^6.0.1",
@@ -483,7 +483,7 @@
     "tsx": "^4.19.3",
     "type-fest": "^4.39.1",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.29.0"
+    "typescript-eslint": "^8.29.1"
   },
   "overrides": {
     "esbuild": "$esbuild"