obsidian-dev-utils 22.1.1-beta.8 → 23.0.0

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

@@ -1,21 +1,25 @@
 /**
- * @packageDocumentation PluginBase
+ * @packageDocumentation
+ *
  * Base class for Obsidian plugins providing utility methods for settings management, error handling, and notifications.
  *
  * This class simplifies the process of managing plugin settings, displaying notifications, and handling errors.
  * Subclasses should implement methods to create default settings and settings tabs, and complete plugin-specific
  * loading tasks.
  */
-import type { PluginSettingTab } from 'obsidian';
-import type { Promisable, ReadonlyDeep } from 'type-fest';
-import { Plugin } from 'obsidian';
-import { PluginSettingsManagerBase } from './PluginSettingsManagerBase.cjs';
+import type { ReadonlyDeep } from 'type-fest';
+import { Plugin as ObsidianPlugin } from 'obsidian';
+import type { AsyncEventRef } from '../../AsyncEvents.cjs';
+import type { ExtractPluginSettings, ExtractPluginSettingsManager, ExtractPluginSettingsTab, PluginTypesBase } from './PluginTypesBase.cjs';
+import { AsyncEvents } from '../../AsyncEvents.cjs';
+type LifecycleEventName = 'layoutReady' | 'load' | 'unload';
 /**
  * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.
  *
  * @typeParam PluginSettings - The type representing the plugin settings object.
  */
-export declare abstract class PluginBase<PluginSettings extends object = object> extends Plugin {
+export declare abstract class PluginBase<PluginTypes extends PluginTypesBase> extends ObsidianPlugin {
+    readonly events: AsyncEvents;
     /**
      * Gets the AbortSignal used for aborting long-running operations.
      *
@@ -27,10 +31,13 @@ export declare abstract class PluginBase<PluginSettings extends object = object>
      *
      * @returns The readonly plugin settings.
      */
-    get settings(): ReadonlyDeep<PluginSettings>;
-    get settingsManager(): PluginSettingsManagerBase<PluginSettings>;
+    get settings(): ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;
+    get settingsManager(): ExtractPluginSettingsManager<PluginTypes>;
+    get settingsTab(): ExtractPluginSettingsTab<PluginTypes>;
     private _abortSignal;
     private _settingsManager;
+    private _settingsTab;
+    private lifecycleEventNames;
     private notice?;
     /**
      * Logs a message to the console.
@@ -53,44 +60,68 @@ export declare abstract class PluginBase<PluginSettings extends object = object>
      * Called when the plugin is loaded
      */
     onload(): Promise<void>;
+    /**
+     * Called when the plugin settings are loaded or reloaded.
+     *
+     * @param _settings - The settings.
+     */
+    onLoadSettings(_settings: ExtractPluginSettings<PluginTypes>): Promise<void>;
     /**
      * Called when the plugin settings are saved.
      *
      * @param _newSettings - The new settings.
      * @param _oldSettings - The old settings.
-     * @returns A promise or void indicating the completion of the save process.
      */
-    onSaveSettings(_newSettings: Partial<PluginSettings>, _oldSettings: Partial<PluginSettings>): Promise<void>;
+    onSaveSettings(_newSettings: ExtractPluginSettings<PluginTypes>, _oldSettings: ExtractPluginSettings<PluginTypes>): Promise<void>;
+    onunload(): void;
+    /**
+     * Registers an async event.
+     * Unregisters the event when the plugin is unloaded.
+     *
+     * @param eventRef - The event reference.
+     */
+    registerAsyncEvent(eventRef: AsyncEventRef): void;
     /**
-     * Creates a plugin settings tab. This method must be implemented by subclasses.
+     * Waits for a lifecycle event to be triggered.
+     *
+     * If you `await` this method during lifecycle event, it might cause a deadlock.
+     *
+     * Consider wrapping this call with {@link invokeAsyncSafely}.
+     *
+     * @param name - The name of the event.
+     * @returns A {@link Promise} that resolves when the event is triggered.
+     */
+    waitForLifecycleEvent(name: LifecycleEventName): Promise<void>;
+    /**
+     * Creates a plugin settings tab.
      *
      * @returns The settings tab or null if not applicable.
      */
-    protected abstract createPluginSettingsTab(): null | PluginSettingTab;
+    protected createPluginSettingsTab(): ExtractPluginSettingsTab<PluginTypes> | null;
     /**
      * Creates the plugin settings manager. This method must be implemented by subclasses.
      *
      * @returns The plugin settings manager.
      */
-    protected abstract createSettingsManager(): PluginSettingsManagerBase<PluginSettings>;
+    protected createSettingsManager(): ExtractPluginSettingsManager<PluginTypes> | null;
     /**
      * Called when the layout is ready. This method can be overridden by subclasses to perform actions once
      * the layout is ready.
-     *
-     * @returns A promise or void indicating the completion of the layout setup.
      */
-    protected onLayoutReady(): Promisable<void>;
+    protected onLayoutReady(): Promise<void>;
+    protected onloadImpl(): Promise<void>;
     /**
-     * Called when the plugin loading is complete. This method must be implemented by subclasses to perform
-     * any additional setup required after loading is complete.
-     *
-     * @returns A promise or void indicating the completion of the load process.
+     * Called when the plugin is unloaded.
      */
-    protected onloadComplete(): Promisable<void>;
+    protected onunloadImpl(): Promise<void>;
     /**
      * Displays a notice message to the user.
      *
      * @param message - The message to display.
      */
     protected showNotice(message: string): void;
+    private afterLoad;
+    private onLayoutReadyBase;
+    private triggerLifecycleEvent;
 }
+export {};

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

@@ -59,4 +59,4 @@ function getPluginContextWindow() {
 0 && (module.exports = {
   initPluginContext
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,6 @@
 /**
- * @packageDocumentation PluginContext
+ * @packageDocumentation
+ *
  * Initializes the plugin context and sets up the plugin ID.
  */
 import type { App } from 'obsidian';

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

@@ -46,4 +46,4 @@ function setPluginId(newPluginId) {
   getPluginId,
   setPluginId
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL1BsdWdpbi9QbHVnaW5JZC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb24gUGx1Z2luSWRcbiAqIEhvbGRlciBmb3IgdGhlIHBsdWdpbiBJRC5cbiAqL1xuXG4vKipcbiAqIFRoZSBwbHVnaW4gSUQgZm9yIG5vIHBsdWdpbi5cbiAqL1xuZXhwb3J0IGNvbnN0IE5PX1BMVUdJTl9JRF9JTklUSUFMSVpFRCA9ICdfX25vLXBsdWdpbi1pZC1pbml0aWFsaXplZF9fJztcblxubGV0IHBsdWdpbklkID0gTk9fUExVR0lOX0lEX0lOSVRJQUxJWkVEO1xuXG4vKipcbiAqIFJldHVybnMgdGhlIHBsdWdpbiBJRC5cbiAqXG4gKiBAcmV0dXJucyBUaGUgcGx1Z2luIElELlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0UGx1Z2luSWQoKTogc3RyaW5nIHtcbiAgcmV0dXJuIHBsdWdpbklkO1xufVxuXG4vKipcbiAqIFNldHMgdGhlIHBsdWdpbiBJRC5cbiAqXG4gKiBAcGFyYW0gbmV3UGx1Z2luSWQgLSBUaGUgbmV3IHBsdWdpbiBJRC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNldFBsdWdpbklkKG5ld1BsdWdpbklkOiBzdHJpbmcpOiB2b2lkIHtcbiAgaWYgKG5ld1BsdWdpbklkKSB7XG4gICAgcGx1Z2luSWQgPSBuZXdQbHVnaW5JZDtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBUU8sTUFBTSwyQkFBMkI7QUFFeEMsSUFBSSxXQUFXO0FBT1IsU0FBUyxjQUFzQjtBQUNwQyxTQUFPO0FBQ1Q7QUFPTyxTQUFTLFlBQVksYUFBMkI7QUFDckQsTUFBSSxhQUFhO0FBQ2YsZUFBVztBQUFBLEVBQ2I7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL1BsdWdpbi9QbHVnaW5JZC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqXG4gKiBIb2xkZXIgZm9yIHRoZSBwbHVnaW4gSUQuXG4gKi9cblxuLyoqXG4gKiBUaGUgcGx1Z2luIElEIGZvciBubyBwbHVnaW4uXG4gKi9cbmV4cG9ydCBjb25zdCBOT19QTFVHSU5fSURfSU5JVElBTElaRUQgPSAnX19uby1wbHVnaW4taWQtaW5pdGlhbGl6ZWRfXyc7XG5cbmxldCBwbHVnaW5JZCA9IE5PX1BMVUdJTl9JRF9JTklUSUFMSVpFRDtcblxuLyoqXG4gKiBSZXR1cm5zIHRoZSBwbHVnaW4gSUQuXG4gKlxuICogQHJldHVybnMgVGhlIHBsdWdpbiBJRC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFBsdWdpbklkKCk6IHN0cmluZyB7XG4gIHJldHVybiBwbHVnaW5JZDtcbn1cblxuLyoqXG4gKiBTZXRzIHRoZSBwbHVnaW4gSUQuXG4gKlxuICogQHBhcmFtIG5ld1BsdWdpbklkIC0gVGhlIG5ldyBwbHVnaW4gSUQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZXRQbHVnaW5JZChuZXdQbHVnaW5JZDogc3RyaW5nKTogdm9pZCB7XG4gIGlmIChuZXdQbHVnaW5JZCkge1xuICAgIHBsdWdpbklkID0gbmV3UGx1Z2luSWQ7XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVNPLE1BQU0sMkJBQTJCO0FBRXhDLElBQUksV0FBVztBQU9SLFNBQVMsY0FBc0I7QUFDcEMsU0FBTztBQUNUO0FBT08sU0FBUyxZQUFZLGFBQTJCO0FBQ3JELE1BQUksYUFBYTtBQUNmLGVBQVc7QUFBQSxFQUNiO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

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

@@ -1,5 +1,6 @@
 /**
- * @packageDocumentation PluginId
+ * @packageDocumentation
+ *
  * Holder for the plugin ID.
  */
 /**

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

@@ -29,13 +29,12 @@ __export(PluginSettingsManagerBase_exports, {
   PluginSettingsProperty: () => PluginSettingsProperty
 });
 module.exports = __toCommonJS(PluginSettingsManagerBase_exports);
-var import_obsidian = require('obsidian');
 var import_Function = require('../../Function.cjs');
+var import_Object = require('../../Object.cjs');
 var import_DateTransformer = require('../../Transformers/DateTransformer.cjs');
 var import_DurationTransformer = require('../../Transformers/DurationTransformer.cjs');
 var import_GroupTransformer = require('../../Transformers/GroupTransformer.cjs');
 var import_SkipPrivatePropertyTransformer = require('../../Transformers/SkipPrivatePropertyTransformer.cjs');
-var import_ValidationMessage = require('../ValidationMessage.cjs');
 const defaultTransformer = new import_GroupTransformer.GroupTransformer([
   new import_SkipPrivatePropertyTransformer.SkipPrivatePropertyTransformer(),
   new import_DateTransformer.DateTransformer(),
@@ -70,12 +69,12 @@ class EditableSettingsProxyHandler extends ProxyHandlerBase {
       record[prop] = value;
       return true;
     }
-    property.set(value);
-    this.validationPromise = this.validationPromise.then(() => property.setAndValidate(value));
+    property.setValue(value);
+    this.validationPromise = this.validationPromise.then(() => property.setValueAndValidate(value));
     return true;
   }
   getPropertyValue(property) {
-    return property.get();
+    return property.currentValue;
   }
 }
 class PropertiesMap extends Map {
@@ -92,16 +91,17 @@ class PropertiesMap extends Map {
 }
 class SafeSettingsProxyHandler extends ProxyHandlerBase {
   getPropertyValue(property) {
-    return property.getSafe();
+    return property.safeValue;
   }
 }
 class PluginSettingsManagerBase {
   constructor(plugin) {
     this.plugin = plugin;
+    this.app = plugin.app;
     this.defaultSettings = this.createDefaultSettings();
-    this.addValidators();
+    this.registerValidators();
     this.properties = new PropertiesMap();
-    for (const propertyName of Object.keys(this.defaultSettings)) {
+    for (const propertyName of (0, import_Object.getAllKeys)(this.defaultSettings)) {
       this.properties.set(
         propertyName,
         new PluginSettingsProperty(propertyName, this.defaultSettings[propertyName], this.validators.get(propertyName) ?? import_Function.noop)
@@ -110,6 +110,7 @@ class PluginSettingsManagerBase {
     this.validators.clear();
     this.safeSettings = new Proxy(this.defaultSettings, new SafeSettingsProxyHandler(this.properties));
   }
+  app;
   safeSettings;
   defaultSettings;
   properties;
@@ -126,7 +127,7 @@ class PluginSettingsManagerBase {
   }
   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) {
@@ -140,7 +141,8 @@ class PluginSettingsManagerBase {
     let record = data;
     const originalJson = JSON.stringify(record);
     record = this.getTransformer().transformObjectRecursively(record);
-    await this.prepareRecord(record);
+    await this.onLoadRecord(record);
+    const propertiesToSave = [];
     for (const [propertyName, value] of Object.entries(record)) {
       const property = this.properties.get(propertyName);
       if (!property) {
@@ -155,17 +157,23 @@ class PluginSettingsManagerBase {
         });
         continue;
       }
-      await property.setAndValidate(value);
+      property.setValue(value);
+      propertiesToSave.push(property);
     }
-    const newJson = JSON.stringify(this.prepareRecordToSave());
+    for (const property of propertiesToSave) {
+      await property.setValueAndValidate(property.currentValue);
+      property.save();
+    }
+    const newJson = JSON.stringify(await this.prepareRecordToSave());
     if (newJson !== originalJson) {
-      await this.saveToFile();
+      await this.saveToFileImpl();
     }
+    await this.plugin.onLoadSettings(this.getSavedSettings());
   }
   /**
    * Saves the new plugin settings.
    *
-   * @returns A promise that resolves when the settings are saved.
+   * @returns A {@link Promise} that resolves when the settings are saved.
    */
   async saveToFile() {
     const oldSettings = this.getSavedSettings();
@@ -176,89 +184,114 @@ class PluginSettingsManagerBase {
     if (!hasChanges) {
       return;
     }
-    await this.plugin.saveData(this.prepareRecordToSave());
+    await this.saveToFileImpl();
     await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings);
   }
-  addValidator(propertyName, validator) {
-    this.validators.set(propertyName, validator);
-  }
-  addValidators() {
-    (0, import_Function.noop)();
-  }
   getTransformer() {
     return defaultTransformer;
   }
-  prepareRecord(_record) {
+  /**
+   * Called when the plugin settings are loaded.
+   *
+   * @param _record - The record.
+   */
+  async onLoadRecord(_record) {
+    await (0, import_Function.noopAsync)();
+  }
+  /**
+   * Called when the plugin settings are saving.
+   *
+   * @param _record - The record.
+   */
+  async onSavingRecord(_record) {
+    await (0, import_Function.noopAsync)();
+  }
+  registerValidator(propertyName, validator) {
+    this.validators.set(propertyName, validator);
+  }
+  registerValidators() {
     (0, import_Function.noop)();
   }
   getSavedSettings() {
     const savedSettings = {};
     for (const [propertyName, property] of this.properties.entries()) {
-      savedSettings[propertyName] = property.getSaved();
+      savedSettings[propertyName] = property.lastSavedValue;
     }
     const proto = Object.getPrototypeOf(this.defaultSettings);
     Object.setPrototypeOf(savedSettings, proto);
     return savedSettings;
   }
-  prepareRecordToSave() {
+  async prepareRecordToSave() {
     const settings = {};
     for (const [propertyName, property] of this.properties.entries()) {
-      settings[propertyName] = property.get();
+      settings[propertyName] = property.currentValue;
     }
+    await this.onSavingRecord(settings);
     return this.getTransformer().transformObjectRecursively(settings);
   }
+  async saveToFileImpl() {
+    await this.plugin.saveData(await this.prepareRecordToSave());
+  }
 }
 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 = "";
-  savedValue;
-  value;
-  clear() {
-    this.value = void 0;
+  reset() {
+    this._currentValue = this.defaultValue;
     this._validationMessage = "";
   }
-  get() {
-    return this.value ?? this.defaultValue;
-  }
-  getSafe() {
-    return this._validationMessage ? this.defaultValue : this.get();
-  }
-  getSaved() {
-    return this.savedValue;
-  }
   save() {
-    if (this.savedValue === this.value) {
+    if (this._lastSavedValue === this._currentValue) {
       return false;
     }
-    this.savedValue = this.value;
+    this._lastSavedValue = this._currentValue;
     return true;
   }
-  set(value) {
-    if ((0, import_ValidationMessage.isValidationMessageHolder)(value)) {
-      this._validationMessage = value.validationMessage;
-    } else {
-      this.value = value;
-    }
+  setValidationMessage(validationMessage) {
+    this._validationMessage = validationMessage;
+    this.showWarning();
   }
-  async setAndValidate(value) {
-    this.set(value);
-    if (this.value === void 0) {
-      return;
+  setValue(value) {
+    this._currentValue = value;
+  }
+  async setValueAndValidate(value) {
+    this.setValue(value);
+    try {
+      this._validationMessage = await this.validator(this._currentValue) ?? "";
+    } catch (error) {
+      console.error("Validation failed", {
+        propertyName: this.propertyName,
+        value
+      }, error);
+      this._validationMessage = "Validation failed";
     }
-    this._validationMessage = await this.validator(this.value) ?? "";
+    this.showWarning(value);
+  }
+  showWarning(value) {
     if (!this._validationMessage) {
       return;
     }
-    const warningMessage = `Could not set plugin setting: ${this.propertyName}. Using default value instead.`;
-    new import_obsidian.Notice(warningMessage);
-    console.warn(warningMessage, {
+    console.warn(`Could not set plugin setting: ${this.propertyName}. Using default value instead.`, {
       defaultValue: this.defaultValue,
       propertyName: this.propertyName,
       validationMessage: this._validationMessage,
@@ -271,4 +304,4 @@ class PluginSettingsProperty {
   PluginSettingsManagerBase,
   PluginSettingsProperty
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["import type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport { Notice } from 'obsidian';\n\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../Object.ts';\nimport type { Transformer } from '../../Transformers/Transformer.ts';\nimport type { ValidationMessageHolder } from '../ValidationMessage.ts';\nimport type { PluginBase } from './PluginBase.ts';\n\nimport { noop } 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';\nimport { isValidationMessageHolder } from '../ValidationMessage.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.set(value);\n    this.validationPromise = this.validationPromise.then(() => property.setAndValidate(value));\n\n    return true;\n  }\n\n  protected override getPropertyValue(property: PluginSettingsProperty<unknown>): unknown {\n    return property.get();\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.getSafe();\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 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(private plugin: PluginBase<PluginSettings>) {\n    this.defaultSettings = this.createDefaultSettings();\n\n    this.addValidators();\n\n    this.properties = new PropertiesMap<PluginSettings>();\n\n    for (const propertyName of Object.keys(this.defaultSettings) as StringKeys<PluginSettings>[]) {\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.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    const originalJson = JSON.stringify(record);\n    record = this.getTransformer().transformObjectRecursively(record);\n    await this.prepareRecord(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.setAndValidate(value);\n    }\n\n    const newJson = JSON.stringify(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(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 prepareRecord(_record: Record<string, unknown>): Promisable<void> {\n    noop();\n  }\n\n  private getSavedSettings(): Partial<PluginSettings> {\n    const savedSettings: Partial<PluginSettings> = {};\n    for (const [propertyName, property] of this.properties.entries()) {\n      savedSettings[propertyName as StringKeys<PluginSettings>] = property.getSaved() as PluginSettings[StringKeys<PluginSettings>] | undefined;\n    }\n    const proto = Object.getPrototypeOf(this.defaultSettings) as object;\n    Object.setPrototypeOf(savedSettings, proto);\n    return savedSettings;\n  }\n\n  private prepareRecordToSave(): 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.get() as unknown;\n    }\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 validationMessage(): string {\n    return this._validationMessage;\n  }\n\n  private _validationMessage = '';\n\n  private savedValue: T | undefined;\n\n  private value: T | undefined;\n  public constructor(private readonly propertyName: string, public readonly defaultValue: T, private readonly validator: Validator<T>) {}\n\n  public clear(): void {\n    this.value = undefined;\n    this._validationMessage = '';\n  }\n\n  public get(): T {\n    return this.value ?? this.defaultValue;\n  }\n\n  public getSafe(): T {\n    return this._validationMessage ? this.defaultValue : this.get();\n  }\n\n  public getSaved(): T | undefined {\n    return this.savedValue;\n  }\n\n  public save(): boolean {\n    if (this.savedValue === this.value) {\n      return false;\n    }\n\n    this.savedValue = this.value;\n    return true;\n  }\n\n  public set(value: T | undefined | ValidationMessageHolder): void {\n    if (isValidationMessageHolder(value)) {\n      this._validationMessage = value.validationMessage;\n    } else {\n      this.value = value;\n    }\n  }\n\n  public async setAndValidate(value: T | undefined | ValidationMessageHolder): Promise<void> {\n    this.set(value);\n    if (this.value === undefined) {\n      return;\n    }\n\n    this._validationMessage = (await this.validator(this.value) as string | undefined) ?? '';\n\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": []
}

+//# 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 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<PluginTypes extends PluginTypesBase> {\n  public readonly app: App;\n  public readonly safeSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n\n  private defaultSettings: ExtractPluginSettings<PluginTypes>;\n  private properties: PropertiesMap<ExtractPluginSettings<PluginTypes>>;\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: ExtractPlugin<PluginTypes>) {\n    this.app = plugin.app;\n    this.defaultSettings = this.createDefaultSettings();\n\n    this.registerValidators();\n\n    this.properties = new PropertiesMap<ExtractPluginSettings<PluginTypes>>();\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<ExtractPluginSettings<PluginTypes>>(this.properties)) as ReadonlyDeep<\n      ExtractPluginSettings<PluginTypes>\n    >;\n  }\n\n  public async editAndSave(editor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>): Promise<void> {\n    const editableSettings = new Proxy(this.defaultSettings, 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();\n  }\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  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    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('Invalid value type', {\n          propertyName,\n          propertyType: typeof property.defaultValue,\n          value\n        });\n        continue;\n      }\n\n      property.setValue(value);\n      propertiesToSave.push(property);\n    }\n\n    for (const property of propertiesToSave) {\n      await property.setValueAndValidate(property.currentValue);\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());\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @returns A {@link 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.saveToFileImpl();\n    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings);\n  }\n\n  protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;\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  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  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.defaultSettings) 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  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    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\n      }, error);\n      this._validationMessage = 'Validation failed';\n    }\n    this.showWarning(value);\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": []
}


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

@@ -1,37 +1,55 @@
+/**
+ * @packageDocumentation
+ *
+ * Plugin settings manager base class.
+ */
+import type { App } from 'obsidian';
 import type { Promisable, ReadonlyDeep } from 'type-fest';
-import type { MaybeReturn, StringKeys } from '../../Object.cjs';
 import type { Transformer } from '../../Transformers/Transformer.cjs';
-import type { ValidationMessageHolder } from '../ValidationMessage.cjs';
-import type { PluginBase } from './PluginBase.cjs';
+import type { MaybeReturn, StringKeys } from '../../Type.cjs';
+import type { ExtractPlugin, ExtractPluginSettings, PluginTypesBase } from './PluginTypesBase.cjs';
 type Validator<T> = (value: T) => Promisable<MaybeReturn<string>>;
 /**
  * Base class for managing plugin settings.
  *
  * @typeParam PluginSettings - The type representing the plugin settings object.
  */
-export declare abstract class PluginSettingsManagerBase<PluginSettings extends object> {
-    private plugin;
-    readonly safeSettings: ReadonlyDeep<PluginSettings>;
+export declare abstract class PluginSettingsManagerBase<PluginTypes extends PluginTypesBase> {
+    readonly plugin: ExtractPlugin<PluginTypes>;
+    readonly app: App;
+    readonly safeSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;
     private defaultSettings;
     private properties;
     private validators;
-    constructor(plugin: PluginBase<PluginSettings>);
-    editAndSave(editor: (settings: PluginSettings) => Promisable<void>): Promise<void>;
-    getProperty<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName): PluginSettingsProperty<PluginSettings[PropertyName]>;
+    constructor(plugin: ExtractPlugin<PluginTypes>);
+    editAndSave(editor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>): Promise<void>;
+    getProperty<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(propertyName: PropertyName): PluginSettingsProperty<ExtractPluginSettings<PluginTypes>[PropertyName]>;
     loadFromFile(): Promise<void>;
     /**
      * Saves the new plugin settings.
      *
-     * @returns A promise that resolves when the settings are saved.
+     * @returns A {@link Promise} that resolves when the settings are saved.
      */
     saveToFile(): Promise<void>;
-    protected addValidator<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName, validator: Validator<PluginSettings[PropertyName]>): void;
-    protected addValidators(): void;
-    protected abstract createDefaultSettings(): PluginSettings;
+    protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;
     protected getTransformer(): Transformer;
-    protected prepareRecord(_record: Record<string, unknown>): Promisable<void>;
+    /**
+     * Called when the plugin settings are loaded.
+     *
+     * @param _record - The record.
+     */
+    protected onLoadRecord(_record: Record<string, unknown>): Promise<void>;
+    /**
+     * Called when the plugin settings are saving.
+     *
+     * @param _record - The record.
+     */
+    protected onSavingRecord(_record: Record<string, unknown>): Promise<void>;
+    protected registerValidator<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(propertyName: PropertyName, validator: Validator<ExtractPluginSettings<PluginTypes>[PropertyName]>): void;
+    protected registerValidators(): void;
     private getSavedSettings;
     private prepareRecordToSave;
+    private saveToFileImpl;
 }
 /**
  * A property of a plugin settings.
@@ -42,17 +60,19 @@ 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;
-    private savedValue;
-    private value;
     constructor(propertyName: string, defaultValue: T, validator: Validator<T>);
-    clear(): void;
-    get(): T;
-    getSafe(): T;
-    getSaved(): T | undefined;
+    reset(): void;
     save(): boolean;
-    set(value: T | undefined | ValidationMessageHolder): void;
-    setAndValidate(value: T | undefined | ValidationMessageHolder): Promise<void>;
+    setValidationMessage(validationMessage: string): void;
+    setValue(value: T): void;
+    setValueAndValidate(value: T): Promise<void>;
+    private showWarning;
 }
 export {};