@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/cjs/components/plugin-settings-component.cjs

@@ -117,20 +117,23 @@ __export(plugin_settings_component_exports, {
   PluginSettingsComponentBase: () => PluginSettingsComponentBase
 });
 module.exports = __toCommonJS(plugin_settings_component_exports);
-var import_async_events = require('@mnaoumov/typescript-lib/async-events');
-var import_function = require('@mnaoumov/typescript-lib/function');
-var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
-var import_date_transformer = require('@mnaoumov/typescript-lib/transformers/date-transformer');
-var import_group_transformer = require('@mnaoumov/typescript-lib/transformers/group-transformer');
-var import_map_transformer = require('@mnaoumov/typescript-lib/transformers/map-transformer');
-var import_set_transformer = require('@mnaoumov/typescript-lib/transformers/set-transformer');
-var import_skip_private_property_transformer = require('@mnaoumov/typescript-lib/transformers/skip-private-property-transformer');
-var import_two_way_map_transformer = require('@mnaoumov/typescript-lib/transformers/two-way-map-transformer');
-var import_value_wrapper = require('@mnaoumov/typescript-lib/value-wrapper');
-var import_debug = require('../debug.cjs');
-var import_duration_transformer = require('../transformers/duration-transformer.cjs');
-var import_async_events_component = require('./async-events-component.cjs');
-var import_component_ex = require('./component-ex.cjs');
+var import_async_events = require("@mnaoumov/typescript-lib/async-events");
+var import_function = require("@mnaoumov/typescript-lib/function");
+var import_object_utils = require("@mnaoumov/typescript-lib/object-utils");
+var import_date_transformer = require("@mnaoumov/typescript-lib/transformers/date-transformer");
+var import_group_transformer = require("@mnaoumov/typescript-lib/transformers/group-transformer");
+var import_map_transformer = require("@mnaoumov/typescript-lib/transformers/map-transformer");
+var import_set_transformer = require("@mnaoumov/typescript-lib/transformers/set-transformer");
+var import_skip_private_property_transformer = require("@mnaoumov/typescript-lib/transformers/skip-private-property-transformer");
+var import_two_way_map_transformer = require("@mnaoumov/typescript-lib/transformers/two-way-map-transformer");
+var import_value_wrapper = require("@mnaoumov/typescript-lib/value-wrapper");
+var import_data_handler = require("../data-handler.cjs");
+var import_debug = require("../debug.cjs");
+var import_settings_recovery = require("../settings-recovery.cjs");
+var import_duration_transformer = require("../transformers/duration-transformer.cjs");
+var import_async_events_component = require("./async-events-component.cjs");
+var import_component_ex = require("./component-ex.cjs");
+const JSON_INDENT = 2;
 const defaultTransformer = new import_group_transformer.GroupTransformer([
   new import_skip_private_property_transformer.SkipPrivatePropertyTransformer(),
   new import_date_transformer.DateTransformer(),
@@ -228,6 +231,15 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
       }
     }
   }
+  /**
+   * Lists the recovery copies of `data.json` kept on this device: copies of a file that did not parse, and of a file
+   * whose stored values a first save would have dropped or changed.
+   *
+   * @returns The copies, newest first; none when the data handler keeps no recovery copies.
+   */
+  async getRecoveryCopies() {
+    return await this.dataHandler.recoveryStore?.list() ?? [];
+  }
   /**
    * Gets a safe copy of the settings.
    *
@@ -248,7 +260,24 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
    */
   async loadFromFile(isInitialLoad) {
     this.ensureLoaded();
-    const data = await this.dataHandler.loadData();
+    let data;
+    try {
+      data = await this.dataHandler.loadData();
+    } catch (error) {
+      if (!(error instanceof import_data_handler.PluginDataParseError) || error.recoveryCopy === null) {
+        throw error;
+      }
+      if (isInitialLoad) {
+        this.lastSavedState = this.createDefaultState();
+        this.currentState = this.createDefaultState();
+      }
+      this.markLoadedFromFile();
+      if (isInitialLoad) {
+        await this.asyncEvents.triggerAsync("loadSettings", this.currentState, isInitialLoad);
+      }
+      return;
+    }
+    const originalJson = JSON.stringify(data, void 0, JSON_INDENT);
     this.lastSavedState = this.createDefaultState();
     this.currentState = this.createDefaultState();
     try {
@@ -271,7 +300,7 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
         return;
       }
       const newRecord = await this.settingsToRawRecord(this.currentState.inputValues);
-      if (!(0, import_object_utils.isDeepEqual)(newRecord, data)) {
+      if (!(0, import_object_utils.isDeepEqual)(newRecord, data) && await this.keepCopyBeforeLossyRewrite(originalJson, newRecord)) {
         await this.saveToFileImpl();
       }
     } finally {
@@ -381,6 +410,43 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
   registerValidator(propertyName, validator) {
     this.validators.set(propertyName, validator);
   }
+  /**
+   * Restores a recovery copy of `data.json` kept on this device: writes its record back to the file and reloads the
+   * settings from it.
+   *
+   * The settings in use are kept as a recovery copy of their own first, so a restore loses nothing either.
+   *
+   * @param id - The id of the copy, from {@link getRecoveryCopies}.
+   * @returns A {@link Promise} that resolves when the restored settings are loaded.
+   * @throws If the data handler keeps no recovery copies, no copy has that id, or the copy is not valid JSON (a copy
+   * of an unparseable file has to be repaired by hand first).
+   */
+  async restoreRecoveryCopy(id) {
+    this.ensureLoaded();
+    const recoveryStore = this.dataHandler.recoveryStore;
+    if (!recoveryStore) {
+      throw new Error("The data handler keeps no recovery copies.");
+    }
+    const copies = await recoveryStore.list();
+    const copy = copies.find((candidate) => candidate.id === id);
+    if (!copy) {
+      throw new Error(`No recovery copy "${id}" is kept on this device.`);
+    }
+    let data;
+    try {
+      data = JSON.parse(copy.rawText);
+    } catch (error) {
+      throw new Error(`Recovery copy "${id}" is not valid JSON, so it cannot be restored as it is.`, { cause: error });
+    }
+    const currentRecord = await this.settingsToRawRecord(this.currentState.inputValues);
+    await recoveryStore.keep({
+      path: copy.path,
+      rawText: JSON.stringify(currentRecord, void 0, JSON_INDENT),
+      reason: import_settings_recovery.SettingsRecoveryReason.LossyRewrite
+    });
+    await this.dataHandler.saveData(data);
+    await this.loadFromFile(false);
+  }
   /**
    * Revalidates the settings.
    *
@@ -402,7 +468,12 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
     if ((0, import_object_utils.isDeepEqual)(this.lastSavedState.inputValues, this.currentState.inputValues)) {
       return;
     }
-    await this.saveToFileImpl();
+    try {
+      await this.saveToFileImpl();
+    } catch (error) {
+      this.currentState = await this.cloneState(this.lastSavedState);
+      throw error;
+    }
     await this.asyncEvents.triggerAsync(
       "saveSettings",
       this.currentState,
@@ -563,6 +634,36 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
   isValidPropertyName(property) {
     return typeof property === "string" && this.propertyNames.includes(property);
   }
+  /**
+   * Keeps a recovery copy before the initial load's normalizing save, when that save would drop or change a stored
+   * value: an unknown key (a newer plugin version's setting), a legacy migration, a value the transformer rewrites.
+   * Adding defaults for keys the file lacks loses nothing and keeps no copy.
+   *
+   * @param originalJson - The record as the file held it, serialized before anything could mutate it.
+   * @param newRecord - The record about to be saved.
+   * @returns Whether the save may go ahead: nothing would be lost, a copy was kept, or the handler keeps no copies.
+   */
+  async keepCopyBeforeLossyRewrite(originalJson, newRecord) {
+    const recoveryStore = this.dataHandler.recoveryStore;
+    if (!recoveryStore || originalJson === void 0) {
+      return true;
+    }
+    const originalRecord = JSON.parse(originalJson);
+    if (originalRecord === null) {
+      return true;
+    }
+    const isLossy = Object.keys(originalRecord).some((key) => !Object.hasOwn(newRecord, key) || !(0, import_object_utils.isDeepEqual)(newRecord[key], originalRecord[key]));
+    if (!isLossy) {
+      return true;
+    }
+    try {
+      await recoveryStore.keep({ path: "data.json", rawText: originalJson, reason: import_settings_recovery.SettingsRecoveryReason.LossyRewrite });
+      return true;
+    } catch (error) {
+      console.error(new Error("Could not keep a recovery copy of data.json, so the normalized settings were not saved over it.", { cause: error }));
+      return false;
+    }
+  }
   markLoadedFromFile() {
     this.isLoadedFromFile = true;
     const resolvers = this.loadedFromFileResolvers.splice(0);
@@ -624,4 +725,4 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
 0 && (module.exports = {
   PluginSettingsComponentBase
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/plugin-settings-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Component that manages plugin settings: data, persistence, validation, and events.\n *\n * This is the single public-facing settings API for plugin authors.\n * All settings logic (load, save, validate, transform, clone) is handled directly\n * by this component — no separate manager class is needed.\n */\n\nimport type {\n  AsyncEventRef,\n  AsyncEventSource\n} from '@mnaoumov/typescript-lib/async-events';\nimport type { Transformer } from '@mnaoumov/typescript-lib/transformers/transformer';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '@mnaoumov/typescript-lib/type';\nimport type { GenericObject } from '@mnaoumov/typescript-lib/type-guards';\nimport type {\n  Constructor,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport { AsyncEvents } from '@mnaoumov/typescript-lib/async-events';\nimport {\n  noop,\n  noopAsync\n} from '@mnaoumov/typescript-lib/function';\nimport {\n  castTo,\n  getAllKeys,\n  isDeepEqual\n} from '@mnaoumov/typescript-lib/object-utils';\nimport { DateTransformer } from '@mnaoumov/typescript-lib/transformers/date-transformer';\nimport { GroupTransformer } from '@mnaoumov/typescript-lib/transformers/group-transformer';\nimport { MapTransformer } from '@mnaoumov/typescript-lib/transformers/map-transformer';\nimport { SetTransformer } from '@mnaoumov/typescript-lib/transformers/set-transformer';\nimport { SkipPrivatePropertyTransformer } from '@mnaoumov/typescript-lib/transformers/skip-private-property-transformer';\nimport { TwoWayMapTransformer } from '@mnaoumov/typescript-lib/transformers/two-way-map-transformer';\nimport { ValueWrapper } from '@mnaoumov/typescript-lib/value-wrapper';\n\nimport type { DataHandler } from '../data-handler.ts';\nimport type { PluginEventSource } from '../plugin/plugin-event-source.ts';\n\nimport { getObsidianLibDebugger } from '../debug.ts';\nimport { DurationTransformer } from '../transformers/duration-transformer.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer(),\n  new MapTransformer(),\n  new SetTransformer(),\n  new TwoWayMapTransformer()\n]);\n\n/**\n * Constructor parameters for {@link PluginSettingsComponentBase}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseConstructorParams<PluginSettings> {\n  /**\n   * The data handler for the plugin.\n   */\n  readonly dataHandler: DataHandler;\n\n  /**\n   * The plugin events.\n   */\n  readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class.\n   */\n  readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.onSaveSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings extends object> {\n  /**\n   * The save context.\n   */\n  readonly context: unknown;\n\n  /**\n   * The new settings state.\n   */\n  readonly newState: ReadonlyPluginSettingsState<PluginSettings>;\n\n  /**\n   * The old settings state.\n   */\n  readonly oldState: ReadonlyPluginSettingsState<PluginSettings>;\n}\n\n/**\n * A snapshot of plugin settings state, including raw input values, effective (validated) values,\n * and per-property validation messages.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsState<PluginSettings extends object> {\n  /**\n   * The effective settings values used by the plugin. Invalid properties are replaced with defaults.\n   */\n  readonly effectiveValues: PluginSettings;\n\n  /**\n   * The raw input values as entered by the user. May contain invalid values.\n   */\n  readonly inputValues: PluginSettings;\n\n  /**\n   * Per-property validation messages. Empty string means valid.\n   */\n  readonly validationMessages: Record<StringKeys<PluginSettings>, string>;\n}\n\n/**\n * Readonly version of {@link PluginSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettings<PluginSettings extends object> = ReadonlyDeep<PluginSettings>;\n\n/**\n * Readonly version of {@link PluginSettingsState} for use in event callbacks and public getters.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettingsState<PluginSettings extends object> = ReadonlyDeep<PluginSettingsState<PluginSettings>>;\n\n/**\n * A validator function for a settings property.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam PropertyName - The property name.\n */\nexport type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<string>>;\n\ninterface PluginSettingsComponentBaseEventMap<PluginSettings extends object> {\n  readonly loadSettings: [\n    loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    isInitialLoad: boolean\n  ];\n  readonly saveSettings: [\n    newState: ReadonlyPluginSettingsState<PluginSettings>,\n    oldState: ReadonlyPluginSettingsState<PluginSettings>,\n    context: unknown\n  ];\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.setPropertyImpl}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\ninterface PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings extends object> {\n  /**\n   * The name of the property to set.\n   */\n  readonly propertyName: PropertyNames<PluginSettings>;\n\n  /**\n   * The validation message. Empty or unset means valid.\n   */\n  readonly validationMessage?: string | undefined;\n\n  /**\n   * The value to set.\n   */\n  readonly value: PropertyValues<PluginSettings>;\n}\n\ntype PropertyNames<PluginSettings extends object> = StringKeys<PluginSettings>;\n\ntype PropertyValues<PluginSettings extends object> = PluginSettings[PropertyNames<PluginSettings>];\n\ntype ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;\n\n/**\n * Base class for plugin settings components.\n *\n * Manages settings data, persistence, validation, and events.\n * Plugin authors extend this class and pass their settings class as\n * {@link PluginSettingsComponentBaseConstructorParams.pluginSettingsClass}, whose default-constructed instance supplies the defaults.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\n// eslint-disable-next-line obsidian-dev-toolkit/require-component-suffix -- Non-abstract base class; consumers extend it.\nexport class PluginSettingsComponentBase<PluginSettings extends object> extends ComponentEx implements AsyncEventSource<PluginSettingsComponentBaseEventMap<PluginSettings>> {\n  /**\n   * Gets the readonly default settings.\n   *\n   * @returns The default settings (as a readonly object).\n   */\n  public readonly defaultSettings: ReadonlyDeep<PluginSettings>;\n\n  /**\n   * Gets the readonly effective settings (validated, with defaults substituted for invalid values).\n   *\n   * @returns The readonly effective settings.\n   */\n  public get settings(): ReadonlyDeep<PluginSettings> {\n    return this.settingsState.effectiveValues;\n  }\n\n  /**\n   * Gets the current settings state snapshot.\n   *\n   * @returns The current settings state.\n   */\n  public get settingsState(): ReadonlyPluginSettingsState<PluginSettings> {\n    return this.currentState as ReadonlyPluginSettingsState<PluginSettings>;\n  }\n\n  /**\n   * The data handler used to load and save the plugin settings.\n   */\n  protected readonly dataHandler: DataHandler;\n  /**\n   * The plugin event source the component listens to for external settings changes.\n   */\n  protected readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class used to construct settings instances.\n   */\n  protected readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n  private readonly asyncEvents = new AsyncEvents<PluginSettingsComponentBaseEventMap<PluginSettings>>();\n  private currentState: PluginSettingsState<PluginSettings>;\n\n  private isLoadedFromFile = false;\n\n  private lastSavedState: PluginSettingsState<PluginSettings>;\n\n  private readonly legacySettingsConverters: ((record: GenericObject) => void)[] = [];\n  private readonly loadedFromFileResolvers: (() => void)[] = [];\n  private readonly propertyNames: PropertyNames<PluginSettings>[];\n\n  private readonly validators = new Map<PropertyNames<PluginSettings>, SettingsValidator<PluginSettings>>();\n\n  /**\n   * Creates a new plugin settings component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSettingsComponentBaseConstructorParams<PluginSettings>) {\n    super();\n    this.dataHandler = params.dataHandler;\n    this.pluginSettingsClass = params.pluginSettingsClass;\n    this.pluginEventSource = params.pluginEventSource;\n\n    this.defaultSettings = new this.pluginSettingsClass() as ReadonlyDeep<PluginSettings>;\n    this.currentState = this.createDefaultState();\n    this.lastSavedState = this.createDefaultState();\n    this.propertyNames = getAllKeys(this.currentState.inputValues);\n    this.registerValidators();\n    this.registerLegacySettingsConverters();\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param settingsEditor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(settingsEditor: (settings: PluginSettings) => Promisable<void>, context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    await this.edit(settingsEditor);\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: PluginSettings): Promise<void> {\n    const validationResult = await this.validate(settings);\n    const defaults = this.defaultSettings as PluginSettings;\n    for (const propertyName of this.propertyNames) {\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- This tests whether a validation message is non-empty, not whether the key exists.\n      if (validationResult[propertyName]) {\n        settings[propertyName] = defaults[propertyName];\n      }\n    }\n  }\n\n  /**\n   * Gets a safe copy of the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the safe copy of the settings.\n   */\n  public async getSafeCopy(settings: PluginSettings): Promise<PluginSettings> {\n    const safeSettings = await this.cloneSettings(settings);\n    await this.ensureSafe(safeSettings);\n    return safeSettings;\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. Only the initial load\n   * writes the normalized record back to `data.json`; a reload applies it in memory only.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    this.ensureLoaded();\n    const data = await this.dataHandler.loadData();\n    this.lastSavedState = this.createDefaultState();\n    this.currentState = this.createDefaultState();\n\n    try {\n      if (data !== undefined && data !== null && typeof data !== 'object') {\n        console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);\n        return;\n      }\n\n      // Nothing stored is read as an empty record rather than skipped, so the save below writes the full\n      // default record. Without it a user who never changed a setting has no `data.json` at all, looks\n      // exactly like a fresh install, and silently picks up every default a later release changes.\n      const rawRecord = (data ?? {}) as GenericObject;\n      const parsedSettings = await this.rawRecordToSettings(rawRecord);\n      const validationResult = await this.validate(parsedSettings);\n\n      for (const propertyName of this.propertyNames) {\n        this.setPropertyImpl({\n          propertyName,\n          validationMessage: validationResult[propertyName],\n          value: parsedSettings[propertyName]\n        });\n      }\n\n      this.lastSavedState = await this.cloneState(this.currentState);\n\n      // A component that knows no property names cannot normalize anything: `settingsToRawRecord()` can\n      // only ever return `{}`, so the save below would not rewrite `data.json` -- it would empty it.\n      // `PluginBase` adds a placeholder `PluginSettingsComponentBase<object>` before `onloadImpl()` swaps\n      // in the plugin's own component, and that placeholder is exactly this case: it read every real\n      // setting, kept none of them, and saved the difference back over the file.\n      //\n      // A reload caused by an external change (a sync tool, another device) applies the normalized\n      // settings in memory and never writes them back. Two synced devices whose normalization differs\n      // (different plugin versions, or any normalization that is not a fixed point) would otherwise\n      // rewrite each other's `data.json` on every reload, and the sync tool would carry each rewrite\n      // back, forever (`obsidian-custom-attachment-location` #102). The initial load still writes:\n      // the default record and the legacy migrations depend on it.\n      if (this.propertyNames.length === 0 || !isInitialLoad) {\n        return;\n      }\n\n      const newRecord = await this.settingsToRawRecord(this.currentState.inputValues);\n\n      if (!isDeepEqual(newRecord, data)) {\n        await this.saveToFileImpl();\n      }\n    } finally {\n      this.markLoadedFromFile();\n      await this.asyncEvents.triggerAsync('loadSettings', this.currentState as ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad);\n    }\n  }\n\n  /**\n   * Remove an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   */\n  public off<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void {\n    this.asyncEvents.off(name, callback);\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    this.asyncEvents.offref(eventRef);\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public on<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.on(name, callback, thisArgument);\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * Add an event listener that will be called only once.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public once<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.once(name, callback, thisArgument);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * @returns A {@link Promise} that resolves when the settings are reloaded.\n   */\n  public async onExternalSettingsChange(): Promise<void> {\n    this.ensureLoaded();\n    await this.loadFromFile(false);\n  }\n\n  /**\n   * Loads settings from file and registers event handlers.\n   */\n  public override async onloadAsync(): Promise<void> {\n    registerAsyncEvent(this, this.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this, this.on('saveSettings', (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));\n    registerAsyncEvent(this, this.pluginEventSource.on('externalSettingsChange', this.onExternalSettingsChange.bind(this)));\n    await this.loadFromFile(true);\n  }\n\n  /**\n   * Registers a legacy settings converter.\n   *\n   * @typeParam LegacySettings - The legacy settings class.\n   * @param legacySettingsClass - The legacy settings class.\n   * @param converter - The converter.\n   */\n  public registerLegacySettingsConverter<LegacySettings extends object>(\n    legacySettingsClass: new () => LegacySettings,\n    converter: (legacySettings: Partial<LegacySettings> & Partial<PluginSettings>) => void\n  ): void {\n    const thisWrapper = ValueWrapper.of(this);\n    this.legacySettingsConverters.push(legacySettingsConverter);\n\n    function legacySettingsConverter(record: GenericObject): void {\n      const legacySettingsKeys = new Set<string>(Object.keys(new legacySettingsClass()));\n      const pluginSettingKeys = new Set<string>(thisWrapper.value.propertyNames);\n      const legacySettings = record as Partial<LegacySettings> & Partial<PluginSettings>;\n      converter(legacySettings);\n      for (const key of Object.keys(legacySettings)) {\n        if (pluginSettingKeys.has(key) || !legacySettingsKeys.has(key)) {\n          continue;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n        delete record[key];\n      }\n    }\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @typeParam PropertyName - The name of the settings property.\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  public registerValidator<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    validator: SettingsValidator<PluginSettings, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as SettingsValidator<PluginSettings>);\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns The validation messages.\n   */\n  public async revalidate(): Promise<Record<PropertyNames<PluginSettings>, string>> {\n    this.ensureLoaded();\n    await this.edit(noop);\n    return this.currentState.validationMessages;\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    this.ensureLoaded();\n    if (isDeepEqual(this.lastSavedState.inputValues, this.currentState.inputValues)) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.asyncEvents.triggerAsync(\n      'saveSettings',\n      this.currentState as ReadonlyPluginSettingsState<PluginSettings>,\n      this.lastSavedState as ReadonlyPluginSettingsState<PluginSettings>,\n      context\n    );\n    this.lastSavedState = await this.cloneState(this.currentState);\n  }\n\n  /**\n   * Sets the value of a property.\n   *\n   * @typeParam PropertyName - The name of the property.\n   * @param propertyName - The name of the property.\n   * @param value - The value to set.\n   * @returns A {@link Promise} that resolves to the validation message.\n   */\n  public async setProperty<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettings[PropertyName]\n  ): Promise<string> {\n    this.ensureLoaded();\n    await this.edit((settings) => {\n      settings[propertyName] = value;\n    });\n    return this.currentState.validationMessages[propertyName];\n  }\n\n  /**\n   * Validates the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the validation result.\n   */\n  public async validate(settings: PluginSettings): Promise<ValidationResult<PluginSettings>> {\n    const result: ValidationResult<PluginSettings> = {};\n    for (const [propertyName, validator] of this.validators) {\n      const validationMessage = await validator(settings[propertyName], settings);\n      if (validationMessage) {\n        result[propertyName] = validationMessage;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Waits until the settings have been read from `data.json` at least once.\n   *\n   * Anything that reads a setting from outside this component has to wait for this, because until the first\n   * {@link loadFromFile} completes {@link settings} still holds the DEFAULTS — reading it earlier answers\n   * with a default rather than with what the user actually stored. That window is easy to miss, since it is\n   * empty on a cold start (the workspace layout is not ready yet, so nothing has run) but wide open on a\n   * runtime enable from the Community Plugins tab or a re-enable after an update, where a layout-ready\n   * handler fires immediately while this component's own async load is still in flight.\n   *\n   * Resolves immediately once the settings have loaded, so a caller that arrives late is not stranded\n   * waiting for an event that has already been raised. Later reloads (an external `data.json` change) do\n   * not reset it — the question it answers is whether the settings have EVER been read, not whether the\n   * most recent read has finished.\n   *\n   * @returns A {@link Promise} that resolves once the settings have been loaded from the file.\n   */\n  public whenLoadedFromFile(): Promise<void> {\n    return this.isLoadedFromFile\n      ? noopAsync()\n      : new Promise<void>((resolve) => {\n        this.loadedFromFileResolvers.push(resolve);\n      });\n  }\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 record is loaded from disk.\n   *\n   * @param record - The record.\n   */\n  protected async onLoadRecord(record: GenericObject): Promise<void> {\n    for (const converter of this.legacySettingsConverters) {\n      converter(record);\n    }\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are loaded or reloaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether this is the initial load.\n   */\n  protected async onLoadSettings(\n    _loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    _isInitialLoad: boolean\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are saved.\n   *\n   * @param params - The parameters.\n   */\n  protected async onSaveSettings(params: PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings>): Promise<void> {\n    const {\n      context: _context,\n      newState: _newState,\n      oldState: _oldState\n    } = params;\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings record is about to be saved to disk.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers the legacy settings converters.\n   * Override to register legacy settings converters.\n   */\n  protected registerLegacySettingsConverters(): void {\n    noop();\n  }\n\n  /**\n   * Registers the validators.\n   * Override to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private async cloneSettings(settings: PluginSettings): Promise<PluginSettings> {\n    const record = await this.settingsToRawRecord(settings);\n    const json = JSON.stringify(record);\n    const cloneRecord = JSON.parse(json) as GenericObject;\n    return await this.rawRecordToSettings(cloneRecord);\n  }\n\n  private async cloneState(\n    state: PluginSettingsState<PluginSettings>\n  ): Promise<PluginSettingsState<PluginSettings>> {\n    return {\n      effectiveValues: await this.cloneSettings(state.effectiveValues),\n      inputValues: await this.cloneSettings(state.inputValues),\n      validationMessages: { ...state.validationMessages }\n    };\n  }\n\n  private createDefaultState(): PluginSettingsState<PluginSettings> {\n    return {\n      effectiveValues: new this.pluginSettingsClass(),\n      inputValues: new this.pluginSettingsClass(),\n      validationMessages: castTo<Record<PropertyNames<PluginSettings>, string>>({})\n    };\n  }\n\n  private async edit(settingsEditor: (settings: PluginSettings) => Promisable<void>): Promise<void> {\n    try {\n      await settingsEditor(this.currentState.inputValues);\n    } finally {\n      const validationResult = await this.validate(this.currentState.inputValues);\n      for (const propertyName of this.propertyNames) {\n        const validationMessage = validationResult[propertyName] ?? '';\n        this.currentState.validationMessages[propertyName] = validationMessage;\n        const defaults = this.defaultSettings as PluginSettings;\n        this.currentState.effectiveValues[propertyName] = validationMessage\n          ? defaults[propertyName]\n          : this.currentState.inputValues[propertyName];\n      }\n    }\n  }\n\n  private isValidPropertyName(property: unknown): property is PropertyNames<PluginSettings> {\n    return typeof property === 'string' && (this.propertyNames as string[]).includes(property);\n  }\n\n  private markLoadedFromFile(): void {\n    this.isLoadedFromFile = true;\n    // Drained rather than iterated, so the list does not keep every past waiter alive across reloads.\n    const resolvers = this.loadedFromFileResolvers.splice(0);\n    for (const resolve of resolvers) {\n      resolve();\n    }\n  }\n\n  private async rawRecordToSettings(rawRecord: GenericObject): Promise<PluginSettings> {\n    rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);\n    await this.onLoadRecord(rawRecord);\n\n    const settings = new this.pluginSettingsClass();\n    const defaults = this.defaultSettings as PluginSettings;\n\n    for (const [propertyName, value] of Object.entries(rawRecord)) {\n      if (!this.isValidPropertyName(propertyName)) {\n        getObsidianLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      // JSON cannot hold `undefined`, so only a legacy converter produces it. Keep the default rather than\n      // letting a converter that assigned a key it had nothing for wipe it out.\n      if (value === undefined) {\n        continue;\n      }\n\n      if (typeof value !== typeof defaults[propertyName]) {\n        getObsidianLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(\n          'Possible invalid value type. 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: defaults[propertyName],\n            propertyName,\n            value\n          }\n        );\n      }\n\n      settings[propertyName] = value as PropertyValues<PluginSettings>;\n    }\n\n    return settings;\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.dataHandler.saveData(await this.settingsToRawRecord(this.currentState.inputValues));\n  }\n\n  private setPropertyImpl(params: PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings>): void {\n    const {\n      propertyName,\n      validationMessage,\n      value\n    } = params;\n    const defaults = this.defaultSettings as PluginSettings;\n    this.currentState.inputValues[propertyName] = value;\n    this.currentState.validationMessages[propertyName] = validationMessage ?? '';\n    this.currentState.effectiveValues[propertyName] = validationMessage ? defaults[propertyName] : value;\n  }\n\n  private async settingsToRawRecord(settings: PluginSettings): Promise<GenericObject> {\n    const rawRecord: GenericObject = {};\n\n    for (const propertyName of this.propertyNames) {\n      rawRecord[propertyName] = settings[propertyName];\n    }\n\n    await this.onSavingRecord(rawRecord);\n\n    return this.getTransformer().transformObjectRecursively(rawRecord);\n  }\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/plugin-settings-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Component that manages plugin settings: data, persistence, validation, and events.\n *\n * This is the single public-facing settings API for plugin authors.\n * All settings logic (load, save, validate, transform, clone) is handled directly\n * by this component — no separate manager class is needed.\n */\n\nimport type {\n  AsyncEventRef,\n  AsyncEventSource,\n  CallbackArguments\n} from '@mnaoumov/typescript-lib/async-events';\nimport type { Transformer } from '@mnaoumov/typescript-lib/transformers/transformer';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '@mnaoumov/typescript-lib/type';\nimport type { GenericObject } from '@mnaoumov/typescript-lib/type-guards';\nimport type {\n  Constructor,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport { AsyncEvents } from '@mnaoumov/typescript-lib/async-events';\nimport {\n  noop,\n  noopAsync\n} from '@mnaoumov/typescript-lib/function';\nimport {\n  castTo,\n  getAllKeys,\n  isDeepEqual\n} from '@mnaoumov/typescript-lib/object-utils';\nimport { DateTransformer } from '@mnaoumov/typescript-lib/transformers/date-transformer';\nimport { GroupTransformer } from '@mnaoumov/typescript-lib/transformers/group-transformer';\nimport { MapTransformer } from '@mnaoumov/typescript-lib/transformers/map-transformer';\nimport { SetTransformer } from '@mnaoumov/typescript-lib/transformers/set-transformer';\nimport { SkipPrivatePropertyTransformer } from '@mnaoumov/typescript-lib/transformers/skip-private-property-transformer';\nimport { TwoWayMapTransformer } from '@mnaoumov/typescript-lib/transformers/two-way-map-transformer';\nimport { ValueWrapper } from '@mnaoumov/typescript-lib/value-wrapper';\n\nimport type { DataHandler } from '../data-handler.ts';\nimport type { PluginEventSource } from '../plugin/plugin-event-source.ts';\nimport type { SettingsRecoveryCopy } from '../settings-recovery.ts';\n\nimport { PluginDataParseError } from '../data-handler.ts';\nimport { getObsidianLibDebugger } from '../debug.ts';\nimport { SettingsRecoveryReason } from '../settings-recovery.ts';\nimport { DurationTransformer } from '../transformers/duration-transformer.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * The indentation Obsidian's `Vault.writeJson` uses for `data.json`, so a recovery copy reads like the file did.\n */\nconst JSON_INDENT = 2;\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer(),\n  new MapTransformer(),\n  new SetTransformer(),\n  new TwoWayMapTransformer()\n]);\n\n/**\n * Constructor parameters for {@link PluginSettingsComponentBase}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseConstructorParams<PluginSettings> {\n  /**\n   * The data handler for the plugin.\n   */\n  readonly dataHandler: DataHandler;\n\n  /**\n   * The plugin events.\n   */\n  readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class.\n   */\n  readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.onSaveSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings extends object> {\n  /**\n   * The save context.\n   */\n  readonly context: unknown;\n\n  /**\n   * The new settings state.\n   */\n  readonly newState: ReadonlyPluginSettingsState<PluginSettings>;\n\n  /**\n   * The old settings state.\n   */\n  readonly oldState: ReadonlyPluginSettingsState<PluginSettings>;\n}\n\n/**\n * A snapshot of plugin settings state, including raw input values, effective (validated) values,\n * and per-property validation messages.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsState<PluginSettings extends object> {\n  /**\n   * The effective settings values used by the plugin. Invalid properties are replaced with defaults.\n   */\n  readonly effectiveValues: PluginSettings;\n\n  /**\n   * The raw input values as entered by the user. May contain invalid values.\n   */\n  readonly inputValues: PluginSettings;\n\n  /**\n   * Per-property validation messages. Empty string means valid.\n   */\n  readonly validationMessages: Record<StringKeys<PluginSettings>, string>;\n}\n\n/**\n * Readonly version of {@link PluginSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettings<PluginSettings extends object> = ReadonlyDeep<PluginSettings>;\n\n/**\n * Readonly version of {@link PluginSettingsState} for use in event callbacks and public getters.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettingsState<PluginSettings extends object> = ReadonlyDeep<PluginSettingsState<PluginSettings>>;\n\n/**\n * A validator function for a settings property.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam PropertyName - The property name.\n */\nexport type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<null | string>>;\n\ninterface PluginSettingsComponentBaseEventMap<PluginSettings extends object> {\n  readonly loadSettings: [\n    loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    isInitialLoad: boolean\n  ];\n  readonly saveSettings: [\n    newState: ReadonlyPluginSettingsState<PluginSettings>,\n    oldState: ReadonlyPluginSettingsState<PluginSettings>,\n    context: unknown\n  ];\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.setPropertyImpl}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\ninterface PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings extends object> {\n  /**\n   * The name of the property to set.\n   */\n  readonly propertyName: PropertyNames<PluginSettings>;\n\n  /**\n   * The validation message. Empty or unset means valid.\n   */\n  readonly validationMessage?: string | undefined;\n\n  /**\n   * The value to set.\n   */\n  readonly value: PropertyValues<PluginSettings>;\n}\n\ntype PropertyNames<PluginSettings extends object> = StringKeys<PluginSettings>;\n\ntype PropertyValues<PluginSettings extends object> = PluginSettings[PropertyNames<PluginSettings>];\n\ntype ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;\n\n/**\n * Base class for plugin settings components.\n *\n * Manages settings data, persistence, validation, and events.\n * Plugin authors extend this class and pass their settings class as\n * {@link PluginSettingsComponentBaseConstructorParams.pluginSettingsClass}, whose default-constructed instance supplies the defaults.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\n// eslint-disable-next-line obsidian-dev-toolkit/require-component-suffix -- Non-abstract base class; consumers extend it.\nexport class PluginSettingsComponentBase<PluginSettings extends object> extends ComponentEx implements AsyncEventSource<PluginSettingsComponentBaseEventMap<PluginSettings>> {\n  /**\n   * Gets the readonly default settings.\n   *\n   * @returns The default settings (as a readonly object).\n   */\n  public readonly defaultSettings: ReadonlyDeep<PluginSettings>;\n\n  /**\n   * Gets the readonly effective settings (validated, with defaults substituted for invalid values).\n   *\n   * @returns The readonly effective settings.\n   */\n  public get settings(): ReadonlyDeep<PluginSettings> {\n    return this.settingsState.effectiveValues;\n  }\n\n  /**\n   * Gets the current settings state snapshot.\n   *\n   * @returns The current settings state.\n   */\n  public get settingsState(): ReadonlyPluginSettingsState<PluginSettings> {\n    return this.currentState as ReadonlyPluginSettingsState<PluginSettings>;\n  }\n\n  /**\n   * The data handler used to load and save the plugin settings.\n   */\n  protected readonly dataHandler: DataHandler;\n  /**\n   * The plugin event source the component listens to for external settings changes.\n   */\n  protected readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class used to construct settings instances.\n   */\n  protected readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n  private readonly asyncEvents = new AsyncEvents<PluginSettingsComponentBaseEventMap<PluginSettings>>();\n  private currentState: PluginSettingsState<PluginSettings>;\n\n  private isLoadedFromFile = false;\n\n  private lastSavedState: PluginSettingsState<PluginSettings>;\n\n  private readonly legacySettingsConverters: ((record: GenericObject) => void)[] = [];\n  private readonly loadedFromFileResolvers: (() => void)[] = [];\n  private readonly propertyNames: PropertyNames<PluginSettings>[];\n\n  private readonly validators = new Map<PropertyNames<PluginSettings>, SettingsValidator<PluginSettings>>();\n\n  /**\n   * Creates a new plugin settings component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSettingsComponentBaseConstructorParams<PluginSettings>) {\n    super();\n    this.dataHandler = params.dataHandler;\n    this.pluginSettingsClass = params.pluginSettingsClass;\n    this.pluginEventSource = params.pluginEventSource;\n\n    this.defaultSettings = new this.pluginSettingsClass() as ReadonlyDeep<PluginSettings>;\n    this.currentState = this.createDefaultState();\n    this.lastSavedState = this.createDefaultState();\n    this.propertyNames = getAllKeys(this.currentState.inputValues);\n    this.registerValidators();\n    this.registerLegacySettingsConverters();\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param settingsEditor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(settingsEditor: (settings: PluginSettings) => Promisable<void>, context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    await this.edit(settingsEditor);\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: PluginSettings): Promise<void> {\n    const validationResult = await this.validate(settings);\n    const defaults = this.defaultSettings as PluginSettings;\n    for (const propertyName of this.propertyNames) {\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- This tests whether a validation message is non-empty, not whether the key exists.\n      if (validationResult[propertyName]) {\n        settings[propertyName] = defaults[propertyName];\n      }\n    }\n  }\n\n  /**\n   * Lists the recovery copies of `data.json` kept on this device: copies of a file that did not parse, and of a file\n   * whose stored values a first save would have dropped or changed.\n   *\n   * @returns The copies, newest first; none when the data handler keeps no recovery copies.\n   */\n  public async getRecoveryCopies(): Promise<SettingsRecoveryCopy[]> {\n    return await this.dataHandler.recoveryStore?.list() ?? [];\n  }\n\n  /**\n   * Gets a safe copy of the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the safe copy of the settings.\n   */\n  public async getSafeCopy(settings: PluginSettings): Promise<PluginSettings> {\n    const safeSettings = await this.cloneSettings(settings);\n    await this.ensureSafe(safeSettings);\n    return safeSettings;\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. Only the initial load\n   * writes the normalized record back to `data.json`; a reload applies it in memory only.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    this.ensureLoaded();\n    let data: unknown;\n    try {\n      data = await this.dataHandler.loadData();\n    } catch (error) {\n      // A `data.json` that does not parse is NOT an empty record: reading it as one would save the defaults over the\n      // user's settings. The file is left untouched either way. With a recovery copy kept, the initial load runs on\n      // the defaults in memory and a reload keeps the settings already in memory, and nothing is written until the\n      // user changes a setting. Without a copy the load fails, so nothing can ever be saved over the only copy.\n      if (!(error instanceof PluginDataParseError) || error.recoveryCopy === null) {\n        throw error;\n      }\n      if (isInitialLoad) {\n        this.lastSavedState = this.createDefaultState();\n        this.currentState = this.createDefaultState();\n      }\n      this.markLoadedFromFile();\n      if (isInitialLoad) {\n        await this.asyncEvents.triggerAsync('loadSettings', this.currentState as ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad);\n      }\n      return;\n    }\n    // Taken before anything below can mutate the record: what the file held, for a recovery copy.\n    const originalJson = JSON.stringify(data, undefined, JSON_INDENT);\n    this.lastSavedState = this.createDefaultState();\n    this.currentState = this.createDefaultState();\n\n    try {\n      if (data !== undefined && data !== null && typeof data !== 'object') {\n        console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);\n        return;\n      }\n\n      // Nothing stored is read as an empty record rather than skipped, so the save below writes the full\n      // default record. Without it a user who never changed a setting has no `data.json` at all, looks\n      // exactly like a fresh install, and silently picks up every default a later release changes.\n      const rawRecord = (data ?? {}) as GenericObject;\n      const parsedSettings = await this.rawRecordToSettings(rawRecord);\n      const validationResult = await this.validate(parsedSettings);\n\n      for (const propertyName of this.propertyNames) {\n        this.setPropertyImpl({\n          propertyName,\n          validationMessage: validationResult[propertyName],\n          value: parsedSettings[propertyName]\n        });\n      }\n\n      this.lastSavedState = await this.cloneState(this.currentState);\n\n      // A component that knows no property names cannot normalize anything: `settingsToRawRecord()` can\n      // only ever return `{}`, so the save below would not rewrite `data.json` -- it would empty it.\n      // `PluginBase` adds a placeholder `PluginSettingsComponentBase<object>` before `onloadImpl()` swaps\n      // in the plugin's own component, and that placeholder is exactly this case: it read every real\n      // setting, kept none of them, and saved the difference back over the file.\n      //\n      // A reload caused by an external change (a sync tool, another device) applies the normalized\n      // settings in memory and never writes them back. Two synced devices whose normalization differs\n      // (different plugin versions, or any normalization that is not a fixed point) would otherwise\n      // rewrite each other's `data.json` on every reload, and the sync tool would carry each rewrite\n      // back, forever (`obsidian-custom-attachment-location` #102). The initial load still writes:\n      // the default record and the legacy migrations depend on it.\n      if (this.propertyNames.length === 0 || !isInitialLoad) {\n        return;\n      }\n\n      const newRecord = await this.settingsToRawRecord(this.currentState.inputValues);\n\n      if (!isDeepEqual(newRecord, data) && await this.keepCopyBeforeLossyRewrite(originalJson, newRecord)) {\n        await this.saveToFileImpl();\n      }\n    } finally {\n      this.markLoadedFromFile();\n      await this.asyncEvents.triggerAsync('loadSettings', this.currentState as ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad);\n    }\n  }\n\n  /**\n   * Remove an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   */\n  public off<\n    EventName extends StringKeys<PluginSettingsComponentBaseEventMap<PluginSettings>>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends CallbackArguments<PluginSettingsComponentBaseEventMap<PluginSettings>, EventName>\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void {\n    this.asyncEvents.off(name, callback);\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    this.asyncEvents.offref(eventRef);\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public on<\n    EventName extends StringKeys<PluginSettingsComponentBaseEventMap<PluginSettings>>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends CallbackArguments<PluginSettingsComponentBaseEventMap<PluginSettings>, EventName>\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.on(name, callback, thisArgument);\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * Add an event listener that will be called only once.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public once<\n    EventName extends StringKeys<PluginSettingsComponentBaseEventMap<PluginSettings>>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends CallbackArguments<PluginSettingsComponentBaseEventMap<PluginSettings>, EventName>\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.once(name, callback, thisArgument);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * @returns A {@link Promise} that resolves when the settings are reloaded.\n   */\n  public async onExternalSettingsChange(): Promise<void> {\n    this.ensureLoaded();\n    await this.loadFromFile(false);\n  }\n\n  /**\n   * Loads settings from file and registers event handlers.\n   */\n  public override async onloadAsync(): Promise<void> {\n    registerAsyncEvent(this, this.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this, this.on('saveSettings', (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));\n    registerAsyncEvent(this, this.pluginEventSource.on('externalSettingsChange', this.onExternalSettingsChange.bind(this)));\n    await this.loadFromFile(true);\n  }\n\n  /**\n   * Registers a legacy settings converter.\n   *\n   * @typeParam LegacySettings - The legacy settings class.\n   * @param legacySettingsClass - The legacy settings class.\n   * @param converter - The converter.\n   */\n  public registerLegacySettingsConverter<LegacySettings extends object>(\n    legacySettingsClass: new () => LegacySettings,\n    converter: (legacySettings: Partial<LegacySettings> & Partial<PluginSettings>) => void\n  ): void {\n    const thisWrapper = ValueWrapper.of(this);\n    this.legacySettingsConverters.push(legacySettingsConverter);\n\n    function legacySettingsConverter(record: GenericObject): void {\n      const legacySettingsKeys = new Set<string>(Object.keys(new legacySettingsClass()));\n      const pluginSettingKeys = new Set<string>(thisWrapper.value.propertyNames);\n      const legacySettings = record as Partial<LegacySettings> & Partial<PluginSettings>;\n      converter(legacySettings);\n      for (const key of Object.keys(legacySettings)) {\n        if (pluginSettingKeys.has(key) || !legacySettingsKeys.has(key)) {\n          continue;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n        delete record[key];\n      }\n    }\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @typeParam PropertyName - The name of the settings property.\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  public registerValidator<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    validator: SettingsValidator<PluginSettings, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as SettingsValidator<PluginSettings>);\n  }\n\n  /**\n   * Restores a recovery copy of `data.json` kept on this device: writes its record back to the file and reloads the\n   * settings from it.\n   *\n   * The settings in use are kept as a recovery copy of their own first, so a restore loses nothing either.\n   *\n   * @param id - The id of the copy, from {@link getRecoveryCopies}.\n   * @returns A {@link Promise} that resolves when the restored settings are loaded.\n   * @throws If the data handler keeps no recovery copies, no copy has that id, or the copy is not valid JSON (a copy\n   * of an unparseable file has to be repaired by hand first).\n   */\n  public async restoreRecoveryCopy(id: string): Promise<void> {\n    this.ensureLoaded();\n    const recoveryStore = this.dataHandler.recoveryStore;\n    if (!recoveryStore) {\n      throw new Error('The data handler keeps no recovery copies.');\n    }\n    const copies = await recoveryStore.list();\n    const copy = copies.find((candidate) => candidate.id === id);\n    if (!copy) {\n      throw new Error(`No recovery copy \"${id}\" is kept on this device.`);\n    }\n\n    let data: unknown;\n    try {\n      data = JSON.parse(copy.rawText);\n    } catch (error) {\n      throw new Error(`Recovery copy \"${id}\" is not valid JSON, so it cannot be restored as it is.`, { cause: error });\n    }\n\n    const currentRecord = await this.settingsToRawRecord(this.currentState.inputValues);\n    await recoveryStore.keep({\n      path: copy.path,\n      rawText: JSON.stringify(currentRecord, undefined, JSON_INDENT),\n      reason: SettingsRecoveryReason.LossyRewrite\n    });\n    await this.dataHandler.saveData(data);\n    await this.loadFromFile(false);\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns The validation messages.\n   */\n  public async revalidate(): Promise<Record<PropertyNames<PluginSettings>, string>> {\n    this.ensureLoaded();\n    await this.edit(noop);\n    return this.currentState.validationMessages;\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    this.ensureLoaded();\n    if (isDeepEqual(this.lastSavedState.inputValues, this.currentState.inputValues)) {\n      return;\n    }\n\n    try {\n      await this.saveToFileImpl();\n    } catch (error) {\n      // A refused save (an oversized `data.json`, see `PluginDataHandler`) wrote nothing, so the file still holds\n      // the last saved settings. Put memory back to match it: otherwise every later save would carry the rejected\n      // edit again and fail the same way, and the plugin would run on settings that exist nowhere on disk.\n      this.currentState = await this.cloneState(this.lastSavedState);\n      throw error;\n    }\n    await this.asyncEvents.triggerAsync(\n      'saveSettings',\n      this.currentState as ReadonlyPluginSettingsState<PluginSettings>,\n      this.lastSavedState as ReadonlyPluginSettingsState<PluginSettings>,\n      context\n    );\n    this.lastSavedState = await this.cloneState(this.currentState);\n  }\n\n  /**\n   * Sets the value of a property.\n   *\n   * @typeParam PropertyName - The name of the property.\n   * @param propertyName - The name of the property.\n   * @param value - The value to set.\n   * @returns A {@link Promise} that resolves to the validation message.\n   */\n  public async setProperty<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettings[PropertyName]\n  ): Promise<string> {\n    this.ensureLoaded();\n    await this.edit((settings) => {\n      settings[propertyName] = value;\n    });\n    return this.currentState.validationMessages[propertyName];\n  }\n\n  /**\n   * Validates the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the validation result.\n   */\n  public async validate(settings: PluginSettings): Promise<ValidationResult<PluginSettings>> {\n    const result: ValidationResult<PluginSettings> = {};\n    for (const [propertyName, validator] of this.validators) {\n      const validationMessage = await validator(settings[propertyName], settings);\n      if (validationMessage) {\n        result[propertyName] = validationMessage;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Waits until the settings have been read from `data.json` at least once.\n   *\n   * Anything that reads a setting from outside this component has to wait for this, because until the first\n   * {@link loadFromFile} completes {@link settings} still holds the DEFAULTS — reading it earlier answers\n   * with a default rather than with what the user actually stored. That window is easy to miss, since it is\n   * empty on a cold start (the workspace layout is not ready yet, so nothing has run) but wide open on a\n   * runtime enable from the Community Plugins tab or a re-enable after an update, where a layout-ready\n   * handler fires immediately while this component's own async load is still in flight.\n   *\n   * Resolves immediately once the settings have loaded, so a caller that arrives late is not stranded\n   * waiting for an event that has already been raised. Later reloads (an external `data.json` change) do\n   * not reset it — the question it answers is whether the settings have EVER been read, not whether the\n   * most recent read has finished.\n   *\n   * @returns A {@link Promise} that resolves once the settings have been loaded from the file.\n   */\n  public whenLoadedFromFile(): Promise<void> {\n    return this.isLoadedFromFile\n      ? noopAsync()\n      : new Promise<void>((resolve) => {\n        this.loadedFromFileResolvers.push(resolve);\n      });\n  }\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 record is loaded from disk.\n   *\n   * @param record - The record.\n   */\n  protected async onLoadRecord(record: GenericObject): Promise<void> {\n    for (const converter of this.legacySettingsConverters) {\n      converter(record);\n    }\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are loaded or reloaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether this is the initial load.\n   */\n  protected async onLoadSettings(\n    _loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    _isInitialLoad: boolean\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are saved.\n   *\n   * @param params - The parameters.\n   */\n  protected async onSaveSettings(params: PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings>): Promise<void> {\n    const {\n      context: _context,\n      newState: _newState,\n      oldState: _oldState\n    } = params;\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings record is about to be saved to disk.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers the legacy settings converters.\n   * Override to register legacy settings converters.\n   */\n  protected registerLegacySettingsConverters(): void {\n    noop();\n  }\n\n  /**\n   * Registers the validators.\n   * Override to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private async cloneSettings(settings: PluginSettings): Promise<PluginSettings> {\n    const record = await this.settingsToRawRecord(settings);\n    const json = JSON.stringify(record);\n    const cloneRecord = JSON.parse(json) as GenericObject;\n    return await this.rawRecordToSettings(cloneRecord);\n  }\n\n  private async cloneState(\n    state: PluginSettingsState<PluginSettings>\n  ): Promise<PluginSettingsState<PluginSettings>> {\n    return {\n      effectiveValues: await this.cloneSettings(state.effectiveValues),\n      inputValues: await this.cloneSettings(state.inputValues),\n      validationMessages: { ...state.validationMessages }\n    };\n  }\n\n  private createDefaultState(): PluginSettingsState<PluginSettings> {\n    return {\n      effectiveValues: new this.pluginSettingsClass(),\n      inputValues: new this.pluginSettingsClass(),\n      validationMessages: castTo<Record<PropertyNames<PluginSettings>, string>>({})\n    };\n  }\n\n  private async edit(settingsEditor: (settings: PluginSettings) => Promisable<void>): Promise<void> {\n    try {\n      await settingsEditor(this.currentState.inputValues);\n    } finally {\n      const validationResult = await this.validate(this.currentState.inputValues);\n      for (const propertyName of this.propertyNames) {\n        const validationMessage = validationResult[propertyName] ?? '';\n        this.currentState.validationMessages[propertyName] = validationMessage;\n        const defaults = this.defaultSettings as PluginSettings;\n        this.currentState.effectiveValues[propertyName] = validationMessage\n          ? defaults[propertyName]\n          : this.currentState.inputValues[propertyName];\n      }\n    }\n  }\n\n  private isValidPropertyName(property: unknown): property is PropertyNames<PluginSettings> {\n    return typeof property === 'string' && (this.propertyNames as string[]).includes(property);\n  }\n\n  /**\n   * Keeps a recovery copy before the initial load's normalizing save, when that save would drop or change a stored\n   * value: an unknown key (a newer plugin version's setting), a legacy migration, a value the transformer rewrites.\n   * Adding defaults for keys the file lacks loses nothing and keeps no copy.\n   *\n   * @param originalJson - The record as the file held it, serialized before anything could mutate it.\n   * @param newRecord - The record about to be saved.\n   * @returns Whether the save may go ahead: nothing would be lost, a copy was kept, or the handler keeps no copies.\n   */\n  private async keepCopyBeforeLossyRewrite(originalJson: string | undefined, newRecord: GenericObject): Promise<boolean> {\n    const recoveryStore = this.dataHandler.recoveryStore;\n    if (!recoveryStore || originalJson === undefined) {\n      return true;\n    }\n    // `data.json` held an object or `null` here: anything else was rejected before the save was considered.\n    const originalRecord = JSON.parse(originalJson) as GenericObject | null;\n    if (originalRecord === null) {\n      return true;\n    }\n    const isLossy = Object.keys(originalRecord).some((key) => !Object.hasOwn(newRecord, key) || !isDeepEqual(newRecord[key], originalRecord[key]));\n    if (!isLossy) {\n      return true;\n    }\n\n    try {\n      await recoveryStore.keep({ path: 'data.json', rawText: originalJson, reason: SettingsRecoveryReason.LossyRewrite });\n      return true;\n    } catch (error) {\n      console.error(new Error('Could not keep a recovery copy of data.json, so the normalized settings were not saved over it.', { cause: error }));\n      return false;\n    }\n  }\n\n  private markLoadedFromFile(): void {\n    this.isLoadedFromFile = true;\n    // Drained rather than iterated, so the list does not keep every past waiter alive across reloads.\n    const resolvers = this.loadedFromFileResolvers.splice(0);\n    for (const resolve of resolvers) {\n      resolve();\n    }\n  }\n\n  private async rawRecordToSettings(rawRecord: GenericObject): Promise<PluginSettings> {\n    rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);\n    await this.onLoadRecord(rawRecord);\n\n    const settings = new this.pluginSettingsClass();\n    const defaults = this.defaultSettings as PluginSettings;\n\n    for (const [propertyName, value] of Object.entries(rawRecord)) {\n      if (!this.isValidPropertyName(propertyName)) {\n        getObsidianLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      // JSON cannot hold `undefined`, so only a legacy converter produces it. Keep the default rather than\n      // letting a converter that assigned a key it had nothing for wipe it out.\n      if (value === undefined) {\n        continue;\n      }\n\n      if (typeof value !== typeof defaults[propertyName]) {\n        getObsidianLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(\n          'Possible invalid value type. 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: defaults[propertyName],\n            propertyName,\n            value\n          }\n        );\n      }\n\n      settings[propertyName] = value as PropertyValues<PluginSettings>;\n    }\n\n    return settings;\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.dataHandler.saveData(await this.settingsToRawRecord(this.currentState.inputValues));\n  }\n\n  private setPropertyImpl(params: PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings>): void {\n    const {\n      propertyName,\n      validationMessage,\n      value\n    } = params;\n    const defaults = this.defaultSettings as PluginSettings;\n    this.currentState.inputValues[propertyName] = value;\n    this.currentState.validationMessages[propertyName] = validationMessage ?? '';\n    this.currentState.effectiveValues[propertyName] = validationMessage ? defaults[propertyName] : value;\n  }\n\n  private async settingsToRawRecord(settings: PluginSettings): Promise<GenericObject> {\n    const rawRecord: GenericObject = {};\n\n    for (const propertyName of this.propertyNames) {\n      rawRecord[propertyName] = settings[propertyName];\n    }\n\n    await this.onSavingRecord(rawRecord);\n\n    return this.getTransformer().transformObjectRecursively(rawRecord);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/components/plugin-settings-component.d.cts

@@ -8,13 +8,14 @@
  * All settings logic (load, save, validate, transform, clone) is handled directly
  * by this component — no separate manager class is needed.
  */
-import type { AsyncEventRef, AsyncEventSource } from '@mnaoumov/typescript-lib/async-events' with { 'resolution-mode': 'import' };
+import type { AsyncEventRef, AsyncEventSource, CallbackArguments } from '@mnaoumov/typescript-lib/async-events' with { 'resolution-mode': 'import' };
 import type { Transformer } from '@mnaoumov/typescript-lib/transformers/transformer' with { 'resolution-mode': 'import' };
 import type { MaybeReturn, StringKeys } from '@mnaoumov/typescript-lib/type' with { 'resolution-mode': 'import' };
 import type { GenericObject } from '@mnaoumov/typescript-lib/type-guards' with { 'resolution-mode': 'import' };
 import type { Constructor, Promisable, ReadonlyDeep } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { DataHandler } from '../data-handler.cjs';
 import type { PluginEventSource } from '../plugin/plugin-event-source.cjs';
+import type { SettingsRecoveryCopy } from '../settings-recovery.cjs';
 import { ComponentEx } from './component-ex.cjs';
 /**
  * Constructor parameters for {@link PluginSettingsComponentBase}.
@@ -92,7 +93,7 @@ export type ReadonlyPluginSettingsState<PluginSettings extends object> = Readonl
  * @typeParam PluginSettings - The plugin settings type.
  * @typeParam PropertyName - The property name.
  */
-export type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (value: PluginSettings[PropertyName], settings: PluginSettings) => Promisable<MaybeReturn<string>>;
+export type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (value: PluginSettings[PropertyName], settings: PluginSettings) => Promisable<MaybeReturn<null | string>>;
 interface PluginSettingsComponentBaseEventMap<PluginSettings extends object> {
     readonly loadSettings: [
         loadedState: ReadonlyPluginSettingsState<PluginSettings>,
@@ -177,6 +178,13 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      * @returns A {@link Promise} that resolves when the settings are safe.
      */
     ensureSafe(settings: PluginSettings): Promise<void>;
+    /**
+     * Lists the recovery copies of `data.json` kept on this device: copies of a file that did not parse, and of a file
+     * whose stored values a first save would have dropped or changed.
+     *
+     * @returns The copies, newest first; none when the data handler keeps no recovery copies.
+     */
+    getRecoveryCopies(): Promise<SettingsRecoveryCopy[]>;
     /**
      * Gets a safe copy of the settings.
      *
@@ -200,7 +208,7 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      * @param name - The name of the event.
      * @param callback - The callback to remove.
      */
-    off<EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>, Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void;
+    off<EventName extends StringKeys<PluginSettingsComponentBaseEventMap<PluginSettings>>, Arguments extends CallbackArguments<PluginSettingsComponentBaseEventMap<PluginSettings>, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void;
     /**
      * Remove an event listener by reference.
      *
@@ -219,7 +227,7 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      *
      * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).
      */
-    on<EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>, Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
+    on<EventName extends StringKeys<PluginSettingsComponentBaseEventMap<PluginSettings>>, Arguments extends CallbackArguments<PluginSettingsComponentBaseEventMap<PluginSettings>, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
     /**
      * Trigger an event, executing all the listeners in order even if some of them throw an error.
      *
@@ -234,7 +242,7 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      *
      * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).
      */
-    once<EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>, Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
+    once<EventName extends StringKeys<PluginSettingsComponentBaseEventMap<PluginSettings>>, Arguments extends CallbackArguments<PluginSettingsComponentBaseEventMap<PluginSettings>, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
     /**
      * Called when the external settings change.
      *
@@ -261,6 +269,18 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      * @param validator - The validator.
      */
     registerValidator<PropertyName extends PropertyNames<PluginSettings>>(propertyName: PropertyName, validator: SettingsValidator<PluginSettings, PropertyName>): void;
+    /**
+     * Restores a recovery copy of `data.json` kept on this device: writes its record back to the file and reloads the
+     * settings from it.
+     *
+     * The settings in use are kept as a recovery copy of their own first, so a restore loses nothing either.
+     *
+     * @param id - The id of the copy, from {@link getRecoveryCopies}.
+     * @returns A {@link Promise} that resolves when the restored settings are loaded.
+     * @throws If the data handler keeps no recovery copies, no copy has that id, or the copy is not valid JSON (a copy
+     * of an unparseable file has to be repaired by hand first).
+     */
+    restoreRecoveryCopy(id: string): Promise<void>;
     /**
      * Revalidates the settings.
      *
@@ -354,6 +374,16 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
     private createDefaultState;
     private edit;
     private isValidPropertyName;
+    /**
+     * Keeps a recovery copy before the initial load's normalizing save, when that save would drop or change a stored
+     * value: an unknown key (a newer plugin version's setting), a legacy migration, a value the transformer rewrites.
+     * Adding defaults for keys the file lacks loses nothing and keeps no copy.
+     *
+     * @param originalJson - The record as the file held it, serialized before anything could mutate it.
+     * @param newRecord - The record about to be saved.
+     * @returns Whether the save may go ahead: nothing would be lost, a copy was kept, or the handler keeps no copies.
+     */
+    private keepCopyBeforeLossyRewrite;
     private markLoadedFromFile;
     private rawRecordToSettings;
     private saveToFileImpl;

package/dist/lib/cjs/components/plugin-settings-tab-component.cjs

@@ -117,8 +117,8 @@ __export(plugin_settings_tab_component_exports, {
   PluginSettingsTabComponent: () => PluginSettingsTabComponent
 });
 module.exports = __toCommonJS(plugin_settings_tab_component_exports);
-var import_obsidian = require('obsidian');
-var import_component_ex = require('./component-ex.cjs');
+var import_obsidian = require("obsidian");
+var import_component_ex = require("./component-ex.cjs");
 class PluginSettingsTabComponent extends import_component_ex.ComponentEx {
   /**
    * The plugin the settings tab is registered with.

package/dist/lib/cjs/components/plugin-suggestion-component.cjs

@@ -118,14 +118,14 @@ __export(plugin_suggestion_component_exports, {
   SuggestedPluginState: () => SuggestedPluginState
 });
 module.exports = __toCommonJS(plugin_suggestion_component_exports);
-var import_async = require('@mnaoumov/typescript-lib/async');
-var import_obsidian = require('obsidian');
-var import_css_class = require('../css-class.cjs');
-var import_html_element = require('../html-element.cjs');
-var import_i18n = require('../i18n/i18n.cjs');
-var import_plugin_install_state = require('../plugin/plugin-install-state.cjs');
-var import_component_ex = require('./component-ex.cjs');
-var import_layout_ready_component = require('./layout-ready-component.cjs');
+var import_async = require("@mnaoumov/typescript-lib/async");
+var import_obsidian = require("obsidian");
+var import_css_class = require("../css-class.cjs");
+var import_html_element = require("../html-element.cjs");
+var import_i18n = require("../i18n/i18n.cjs");
+var import_plugin_install_state = require("../plugin/plugin-install-state.cjs");
+var import_component_ex = require("./component-ex.cjs");
+var import_layout_ready_component = require("./layout-ready-component.cjs");
 const SuggestedPluginState = import_plugin_install_state.InstalledPluginState;
 class PluginSuggestionComponent extends import_component_ex.ComponentEx {
   app;

package/dist/lib/cjs/components/pointer-position-component.cjs

@@ -90,8 +90,8 @@ __export(pointer_position_component_exports, {
   PointerPositionComponent: () => PointerPositionComponent
 });
 module.exports = __toCommonJS(pointer_position_component_exports);
-var import_popover_anchor = require('../popovers/popover-anchor.cjs');
-var import_all_windows_event_component = require('./all-windows-event-component.cjs');
+var import_popover_anchor = require("../popovers/popover-anchor.cjs");
+var import_all_windows_event_component = require("./all-windows-event-component.cjs");
 class PointerPositionComponent extends import_all_windows_event_component.AllWindowsEventComponent {
   lastAnchor = null;
   /**

package/dist/lib/cjs/components/reconfigurable-editor-extension-component.cjs

@@ -117,9 +117,9 @@ __export(reconfigurable_editor_extension_component_exports, {
   ReconfigurableEditorExtensionComponent: () => ReconfigurableEditorExtensionComponent
 });
 module.exports = __toCommonJS(reconfigurable_editor_extension_component_exports);
-var import_state = require('@codemirror/state');
-var import_markdown_editor_views = require('../codemirror/markdown-editor-views.cjs');
-var import_component_ex = require('./component-ex.cjs');
+var import_state = require("@codemirror/state");
+var import_markdown_editor_views = require("../codemirror/markdown-editor-views.cjs");
+var import_component_ex = require("./component-ex.cjs");
 class ReconfigurableEditorExtensionComponent extends import_component_ex.ComponentEx {
   /**
    * The extension the editors currently carry, or the one they will carry once the component loads.