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

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

@@ -1,30 +1,24 @@
-import type { ReadonlyDeep } from 'type-fest';
-import { Plugin } from 'obsidian';
-import type { StringKeys } from '../../Object.mjs';
+import type { App } from 'obsidian';
+import type { Promisable, ReadonlyDeep } from 'type-fest';
 import type { Transformer } from '../../Transformers/Transformer.mjs';
-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.mjs';
+import type { PluginBase } from './PluginBase.mjs';
+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,37 @@ 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;
+    protected onLoadRecord(_record: Record<string, unknown>): Promisable<void>;
+    protected onSavingRecord(_record: Record<string, unknown>): Promisable<void>;
+    private getSavedSettings;
+    private prepareRecordToSave;
+}
+/**
+ * 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/esm/obsidian/Plugin/PluginSettingsManagerBase.mjs

@@ -5,8 +5,9 @@ if you want to view the source, please visit the github repository of this plugi
 
 (function initEsm(){if(globalThis.process){return}const browserProcess={browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"};globalThis.process=browserProcess})();
 
-import { Plugin } from "obsidian";
-import { noopAsync } from "../../Function.mjs";
+import { Notice } from "obsidian";
+import { noop } from "../../Function.mjs";
+import { getAllKeys } from "../../Object.mjs";
 import { DateTransformer } from "../../Transformers/DateTransformer.mjs";
 import { DurationTransformer } from "../../Transformers/DurationTransformer.mjs";
 import { GroupTransformer } from "../../Transformers/GroupTransformer.mjs";
@@ -16,68 +17,94 @@ const defaultTransformer = new GroupTransformer([
   new DateTransformer(),
   new DurationTransformer()
 ]);
-class PluginSettingsProperty {
-  constructor(manager, property, defaultValue) {
-    this.manager = manager;
-    this.property = property;
-    this.defaultValue = defaultValue;
-  }
-  validationMessage = "";
-  value;
-  clear() {
-    this.value = void 0;
-    this.validationMessage = "";
+class ProxyHandlerBase {
+  constructor(properties) {
+    this.properties = properties;
   }
-  get() {
-    return this.value ?? this.defaultValue;
-  }
-  getSafe() {
-    return this.validationMessage ? this.defaultValue : this.get();
+  get(target, prop) {
+    const record = target;
+    if (typeof prop !== "string") {
+      return record[prop];
+    }
+    const property = this.properties.get(prop);
+    if (!property) {
+      return record[prop];
+    }
+    return this.getPropertyValue(property);
   }
-  async set(value) {
-    this.value = value;
-    if (this.value !== void 0) {
-      this.validationMessage = await this.manager.validate(this.property, this.value) ?? "";
+}
+class EditableSettingsProxyHandler extends ProxyHandlerBase {
+  validationPromise = Promise.resolve();
+  set(target, prop, value) {
+    const record = target;
+    if (typeof prop !== "string") {
+      record[prop] = value;
+      return true;
+    }
+    const property = this.properties.get(prop);
+    if (!property) {
+      record[prop] = value;
+      return true;
     }
+    property.setValue(value);
+    this.validationPromise = this.validationPromise.then(() => property.setValueAndValidate(value));
+    return true;
+  }
+  getPropertyValue(property) {
+    return property.currentValue;
   }
 }
 class PropertiesMap extends Map {
-  getTyped(key) {
-    const property = super.get(key);
+  getTyped(propertyName) {
+    const property = super.get(propertyName);
     if (!property) {
-      throw new Error(`Property ${String(key)} not found`);
+      throw new Error(`Property ${String(propertyName)} not found`);
     }
     return property;
   }
-  setTyped(key, value) {
-    return super.set(key, value);
+  setTyped(propertyName, value) {
+    return super.set(propertyName, value);
+  }
+}
+class SafeSettingsProxyHandler extends ProxyHandlerBase {
+  getPropertyValue(property) {
+    return property.safeValue;
   }
 }
 class PluginSettingsManagerBase {
   constructor(plugin) {
     this.plugin = plugin;
-    const defaultSettings = this.createDefaultSettings();
+    this.app = plugin.app;
+    this.defaultSettings = this.createDefaultSettings();
+    this.addValidators();
     this.properties = new PropertiesMap();
-    for (const key of Object.keys(defaultSettings)) {
-      this.properties.set(key, new PluginSettingsProperty(this, key, defaultSettings[key]));
-    }
-    this.safeSettings = new Proxy(defaultSettings, {
-      get: (_target, prop) => {
-        if (typeof prop !== "string") {
-          return void 0;
-        }
-        return this.properties.get(prop);
-      }
-    });
+    for (const propertyName of getAllKeys(this.defaultSettings)) {
+      this.properties.set(
+        propertyName,
+        new PluginSettingsProperty(propertyName, this.defaultSettings[propertyName], this.validators.get(propertyName) ?? noop)
+      );
+    }
+    this.validators.clear();
+    this.safeSettings = new Proxy(this.defaultSettings, new SafeSettingsProxyHandler(this.properties));
   }
+  app;
   safeSettings;
+  defaultSettings;
   properties;
-  getProperty(property) {
-    return this.properties.getTyped(property);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  validators = /* @__PURE__ */ new Map();
+  async editAndSave(editor) {
+    const editableSettings = new Proxy(this.defaultSettings, new EditableSettingsProxyHandler(this.properties));
+    await editor(editableSettings);
+    await editableSettings.validationPromise;
+    await this.saveToFile();
+  }
+  getProperty(propertyName) {
+    return this.properties.getTyped(propertyName);
   }
   async loadFromFile() {
     for (const property of this.properties.values()) {
-      property.clear();
+      property.reset();
     }
     const data = await this.plugin.loadData();
     if (data === void 0 || data === null) {
@@ -89,19 +116,28 @@ class PluginSettingsManagerBase {
       return;
     }
     let record = data;
+    const originalJson = JSON.stringify(record);
     record = this.getTransformer().transformObjectRecursively(record);
-    await this.prepareRecord(record);
-    for (const [key, value] of Object.entries(record)) {
-      const propertyObj = this.properties.get(key);
-      if (!propertyObj) {
-        console.warn(`Unknown property: ${key}`);
+    await this.onLoadRecord(record);
+    for (const [propertyName, value] of Object.entries(record)) {
+      const property = this.properties.get(propertyName);
+      if (!property) {
+        console.warn(`Unknown property: ${propertyName}`);
         continue;
       }
-      if (typeof value !== typeof propertyObj.defaultValue) {
-        console.warn(`Invalid value type. Expected ${typeof propertyObj.defaultValue}, got: ${typeof value}`);
+      if (typeof value !== typeof property.defaultValue) {
+        console.warn("Invalid value type", {
+          propertyName,
+          propertyType: typeof property.defaultValue,
+          value
+        });
         continue;
       }
-      await propertyObj.set(value);
+      await property.setValueAndValidate(value);
+    }
+    const newJson = JSON.stringify(await this.prepareRecordToSave());
+    if (newJson !== originalJson) {
+      await this.saveToFile();
     }
   }
   /**
@@ -110,28 +146,115 @@ class PluginSettingsManagerBase {
    * @returns A promise that resolves when the settings are saved.
    */
   async saveToFile() {
-    const record = this.getTransformer().transformObjectRecursively(this.getSettings());
-    await this.plugin.saveData(record);
+    const oldSettings = this.getSavedSettings();
+    let hasChanges = false;
+    for (const property of this.properties.values()) {
+      hasChanges ||= property.save();
+    }
+    if (!hasChanges) {
+      return;
+    }
+    await this.plugin.saveData(await this.prepareRecordToSave());
+    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings);
+  }
+  addValidator(propertyName, validator) {
+    this.validators.set(propertyName, validator);
   }
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  async validate(_property, _value) {
-    await noopAsync();
+  addValidators() {
+    noop();
   }
   getTransformer() {
     return defaultTransformer;
   }
-  async prepareRecord(_record) {
-    await noopAsync();
+  onLoadRecord(_record) {
+    noop();
   }
-  getSettings() {
+  onSavingRecord(_record) {
+    noop();
+  }
+  getSavedSettings() {
+    const savedSettings = {};
+    for (const [propertyName, property] of this.properties.entries()) {
+      savedSettings[propertyName] = property.lastSavedValue;
+    }
+    const proto = Object.getPrototypeOf(this.defaultSettings);
+    Object.setPrototypeOf(savedSettings, proto);
+    return savedSettings;
+  }
+  async prepareRecordToSave() {
     const settings = {};
-    for (const [key, property] of this.properties.entries()) {
-      settings[key] = property.get();
+    for (const [propertyName, property] of this.properties.entries()) {
+      settings[propertyName] = property.currentValue;
     }
-    return settings;
+    await this.onSavingRecord(settings);
+    return this.getTransformer().transformObjectRecursively(settings);
+  }
+}
+class PluginSettingsProperty {
+  constructor(propertyName, defaultValue, validator) {
+    this.propertyName = propertyName;
+    this.defaultValue = defaultValue;
+    this.validator = validator;
+    this._lastSavedValue = defaultValue;
+    this._currentValue = defaultValue;
+  }
+  get currentValue() {
+    return this._currentValue;
+  }
+  get lastSavedValue() {
+    return this._lastSavedValue;
+  }
+  get safeValue() {
+    return this._validationMessage ? this.defaultValue : this._currentValue;
+  }
+  get validationMessage() {
+    return this._validationMessage;
+  }
+  _currentValue;
+  _lastSavedValue;
+  _validationMessage = "";
+  reset() {
+    this._currentValue = this.defaultValue;
+    this._validationMessage = "";
+  }
+  save() {
+    if (this._lastSavedValue === this._currentValue) {
+      return false;
+    }
+    this._lastSavedValue = this._currentValue;
+    return true;
+  }
+  setValidationMessage(validationMessage) {
+    this._validationMessage = validationMessage;
+    this.showWarning();
+  }
+  setValue(value) {
+    this._currentValue = value;
+  }
+  async setValueAndValidate(value) {
+    this.setValue(value);
+    if (this._currentValue === void 0) {
+      return;
+    }
+    this._validationMessage = await this.validator(this._currentValue) ?? "";
+    this.showWarning(value);
+  }
+  showWarning(value) {
+    if (!this._validationMessage) {
+      return;
+    }
+    const warningMessage = `Could not set plugin setting: ${this.propertyName}. Using default value instead.`;
+    new Notice(warningMessage);
+    console.warn(warningMessage, {
+      defaultValue: this.defaultValue,
+      propertyName: this.propertyName,
+      validationMessage: this._validationMessage,
+      value
+    });
   }
 }
 export {
-  PluginSettingsManagerBase
+  PluginSettingsManagerBase,
+  PluginSettingsProperty
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["import type { ReadonlyDeep } from 'type-fest';\n\nimport { Plugin } from 'obsidian';\n\nimport type { StringKeys } from '../../Object.ts';\nimport type { Transformer } from '../../Transformers/Transformer.ts';\n\nimport { noopAsync } from '../../Function.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\nclass PluginSettingsProperty<PluginSettings extends object, Property extends StringKeys<PluginSettings>> {\n  public validationMessage = '';\n  private value: PluginSettings[Property] | undefined;\n\n  public constructor(\n    private readonly manager: PluginSettingsManagerBase<PluginSettings>,\n    private readonly property: Property,\n    public readonly defaultValue: PluginSettings[Property]\n  ) {}\n\n  public clear(): void {\n    this.value = undefined;\n    this.validationMessage = '';\n  }\n\n  public get(): PluginSettings[Property] {\n    return this.value ?? this.defaultValue;\n  }\n\n  public getSafe(): PluginSettings[Property] {\n    return this.validationMessage ? this.defaultValue : this.get();\n  }\n\n  public async set(value: PluginSettings[Property] | undefined): Promise<void> {\n    this.value = value;\n    if (this.value !== undefined) {\n      this.validationMessage = (await this.manager.validate(this.property, this.value) as string | undefined) ?? '';\n    }\n  }\n}\n\nclass PropertiesMap<PluginSettings extends object> extends Map<string, PluginSettingsProperty<PluginSettings, StringKeys<PluginSettings>>> {\n  public getTyped<Property extends StringKeys<PluginSettings>>(key: Property): PluginSettingsProperty<PluginSettings, Property> {\n    const property = super.get(key);\n    if (!property) {\n      throw new Error(`Property ${String(key)} not found`);\n    }\n\n    return property as PluginSettingsProperty<PluginSettings, Property>;\n  }\n\n  public setTyped<Property extends StringKeys<PluginSettings>>(key: Property, value: PluginSettingsProperty<PluginSettings, Property>): this {\n    return super.set(key, value);\n  }\n}\n\n/**\n * Base class for managing plugin settings.\n *\n * @typeParam PluginSettings - The type representing the plugin settings object.\n */\nexport abstract class PluginSettingsManagerBase<PluginSettings extends object> {\n  public readonly safeSettings: ReadonlyDeep<PluginSettings>;\n\n  private properties: PropertiesMap<PluginSettings>;\n\n  public constructor(private plugin: Plugin) {\n    const defaultSettings = this.createDefaultSettings();\n    this.properties = new PropertiesMap<PluginSettings>();\n\n    for (const key of Object.keys(defaultSettings) as StringKeys<PluginSettings>[]) {\n      this.properties.set(key, new PluginSettingsProperty(this, key, defaultSettings[key]));\n    }\n\n    this.safeSettings = new Proxy(defaultSettings, {\n      get: (_target, prop): unknown => {\n        if (typeof prop !== 'string') {\n          return undefined;\n        }\n\n        return this.properties.get(prop);\n      }\n    }) as ReadonlyDeep<PluginSettings>;\n  }\n\n  public getProperty<Property extends StringKeys<PluginSettings>>(property: Property): PluginSettingsProperty<PluginSettings, Property> {\n    return this.properties.getTyped(property);\n  }\n\n  public async loadFromFile(): Promise<void> {\n    for (const property of this.properties.values()) {\n      property.clear();\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    record = this.getTransformer().transformObjectRecursively(record);\n    await this.prepareRecord(record);\n\n    for (const [key, value] of Object.entries(record)) {\n      const propertyObj = this.properties.get(key);\n      if (!propertyObj) {\n        console.warn(`Unknown property: ${key}`);\n        continue;\n      }\n\n      if (typeof value !== typeof propertyObj.defaultValue) {\n        console.warn(`Invalid value type. Expected ${typeof propertyObj.defaultValue}, got: ${typeof value}`);\n        continue;\n      }\n\n      await propertyObj.set(value as PluginSettings[StringKeys<PluginSettings>]);\n    }\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @returns A promise that resolves when the settings are saved.\n   */\n  public async saveToFile(): Promise<void> {\n    const record = this.getTransformer().transformObjectRecursively(this.getSettings());\n    await this.plugin.saveData(record);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type\n  public async validate<Property extends StringKeys<PluginSettings>>(_property: Property, _value: PluginSettings[Property]): Promise<string | void> {\n    await noopAsync();\n  }\n\n  protected abstract createDefaultSettings(): PluginSettings;\n\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  protected async prepareRecord(_record: Record<string, unknown>): Promise<void> {\n    await noopAsync();\n  }\n\n  private getSettings(): Record<StringKeys<PluginSettings>, unknown> {\n    const settings: Record<StringKeys<PluginSettings>, unknown> = {} as Record<StringKeys<PluginSettings>, unknown>;\n    for (const [key, property] of this.properties.entries()) {\n      settings[key as StringKeys<PluginSettings>] = property.get();\n    }\n\n    return settings;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["import type { App } from 'obsidian';\nimport type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport { Notice } from 'obsidian';\n\nimport type { Transformer } from '../../Transformers/Transformer.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../Type.ts';\nimport type { PluginBase } from './PluginBase.ts';\n\nimport { noop } 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<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\n    if (typeof prop !== 'string') {\n      record[prop] = value;\n      return true;\n    }\n\n    const property = this.properties.get(prop);\n    if (!property) {\n      record[prop] = value;\n      return true;\n    }\n\n    property.setValue(value);\n    this.validationPromise = this.validationPromise.then(() => property.setValueAndValidate(value));\n\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 PluginSettings - The type representing the plugin settings object.\n */\nexport abstract class PluginSettingsManagerBase<PluginSettings extends object> {\n  public readonly app: App;\n  public readonly safeSettings: ReadonlyDeep<PluginSettings>;\n\n  private defaultSettings: PluginSettings;\n  private properties: PropertiesMap<PluginSettings>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private validators: Map<string, Validator<any>> = new Map<string, Validator<any>>();\n\n  public constructor(public readonly plugin: PluginBase<PluginSettings>) {\n    this.app = plugin.app;\n    this.defaultSettings = this.createDefaultSettings();\n\n    this.addValidators();\n\n    this.properties = new PropertiesMap<PluginSettings>();\n\n    for (const propertyName of getAllKeys(this.defaultSettings)) {\n      this.properties.set(\n        propertyName,\n        new PluginSettingsProperty(propertyName, this.defaultSettings[propertyName], this.validators.get(propertyName) ?? noop)\n      );\n    }\n\n    this.validators.clear();\n\n    this.safeSettings = new Proxy(this.defaultSettings, new SafeSettingsProxyHandler<PluginSettings>(this.properties)) as ReadonlyDeep<PluginSettings>;\n  }\n\n  public async editAndSave(editor: (settings: PluginSettings) => Promisable<void>): Promise<void> {\n    const editableSettings = new Proxy(this.defaultSettings, new EditableSettingsProxyHandler<PluginSettings>(this.properties)) as {\n      validationPromise: Promise<void>;\n    } & PluginSettings;\n    await editor(editableSettings);\n    await editableSettings.validationPromise;\n    await this.saveToFile();\n  }\n\n  public getProperty<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName): PluginSettingsProperty<PluginSettings[PropertyName]> {\n    return this.properties.getTyped(propertyName);\n  }\n\n  public async loadFromFile(): 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    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('Invalid value type', {\n          propertyName,\n          propertyType: typeof property.defaultValue,\n          value\n        });\n        continue;\n      }\n\n      await property.setValueAndValidate(value);\n    }\n\n    const newJson = JSON.stringify(await this.prepareRecordToSave());\n\n    if (newJson !== originalJson) {\n      await this.saveToFile();\n    }\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @returns A promise that resolves when the settings are saved.\n   */\n  public async saveToFile(): 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.plugin.saveData(await this.prepareRecordToSave());\n    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings);\n  }\n\n  protected addValidator<PropertyName extends StringKeys<PluginSettings>>(\n    propertyName: PropertyName,\n    validator: Validator<PluginSettings[PropertyName]>\n  ): void {\n    this.validators.set(propertyName, validator);\n  }\n\n  protected addValidators(): void {\n    noop();\n  }\n\n  protected abstract createDefaultSettings(): PluginSettings;\n\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  protected onLoadRecord(_record: Record<string, unknown>): Promisable<void> {\n    noop();\n  }\n\n  protected onSavingRecord(_record: Record<string, unknown>): Promisable<void> {\n    noop();\n  }\n\n  private getSavedSettings(): PluginSettings {\n    const savedSettings: Partial<PluginSettings> = {};\n    for (const [propertyName, property] of this.properties.entries()) {\n      savedSettings[propertyName as StringKeys<PluginSettings>] = property.lastSavedValue as PluginSettings[StringKeys<PluginSettings>] | undefined;\n    }\n    const proto = Object.getPrototypeOf(this.defaultSettings) as object;\n    Object.setPrototypeOf(savedSettings, proto);\n    return savedSettings as PluginSettings;\n  }\n\n  private async prepareRecordToSave(): Promise<Record<StringKeys<PluginSettings>, unknown>> {\n    const settings: Record<StringKeys<PluginSettings>, unknown> = {} as Record<StringKeys<PluginSettings>, unknown>;\n    for (const [propertyName, property] of this.properties.entries()) {\n      settings[propertyName as StringKeys<PluginSettings>] = property.currentValue as unknown;\n    }\n\n    await this.onSavingRecord(settings);\n\n    return this.getTransformer().transformObjectRecursively(settings);\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  public get currentValue(): T {\n    return this._currentValue;\n  }\n\n  public get lastSavedValue(): T {\n    return this._lastSavedValue;\n  }\n\n  public get safeValue(): T {\n    return this._validationMessage ? this.defaultValue : this._currentValue;\n  }\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  public constructor(private readonly propertyName: string, public readonly defaultValue: T, private readonly validator: Validator<T>) {\n    this._lastSavedValue = defaultValue;\n    this._currentValue = defaultValue;\n  }\n\n  public reset(): void {\n    this._currentValue = this.defaultValue;\n    this._validationMessage = '';\n  }\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  public setValidationMessage(validationMessage: string): void {\n    this._validationMessage = validationMessage;\n    this.showWarning();\n  }\n\n  public setValue(value: T): void {\n    this._currentValue = value;\n  }\n\n  public async setValueAndValidate(value: T): Promise<void> {\n    this.setValue(value);\n    if (this._currentValue === undefined) {\n      return;\n    }\n\n    this._validationMessage = (await this.validator(this._currentValue) as string | undefined) ?? '';\n    this.showWarning(value);\n  }\n\n  private showWarning(value?: T): void {\n    if (!this._validationMessage) {\n      return;\n    }\n\n    const warningMessage = `Could not set plugin setting: ${this.propertyName}. Using default value instead.`;\n    new Notice(warningMessage);\n    console.warn(warningMessage, {\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.d.mts

@@ -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.mjs';
+import type { StringKeys } from '../../Type.mjs';
 import type { ValueComponentWithChangeTracking } from '../Components/ValueComponentWithChangeTracking.mjs';
+import type { ValidationMessageHolder } from '../ValidationMessage.mjs';
 import type { PluginBase } from './PluginBase.mjs';
 /**
  * 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 {};