obsidian-dev-utils 50.0.0 → 51.1.6

package/dist/lib/esm/obsidian/plugin/plugin-settings-manager-base.d.mts

@@ -0,0 +1,186 @@
+/**
+ * @packageDocumentation
+ *
+ * Plugin settings manager base class.
+ */
+import type { App } from 'obsidian';
+import type { Promisable, ReadonlyDeep } from 'type-fest';
+import type { AsyncEventRef } from '../../async-events.mjs';
+import type { Transformer } from '../../transformers/transformer.mjs';
+import type { GenericObject } from '../../type-guards.mjs';
+import type { MaybeReturn, StringKeys } from '../../type.mjs';
+import type { ExtractPlugin, ExtractPluginSettings, ExtractPluginSettingsPropertyNames, ExtractReadonlyPluginSettingsWrapper, PluginTypesBase } from './plugin-types-base.mjs';
+import { AsyncEvents } from '../../async-events.mjs';
+type ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;
+type Validator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (value: PluginSettings[PropertyName], settings: PluginSettings) => Promisable<MaybeReturn<string>>;
+/**
+ * Base class for managing plugin settings.
+ *
+ * @typeParam PluginTypes - Plugin-specific types.
+ */
+export declare abstract class PluginSettingsManagerBase<PluginTypes extends PluginTypesBase> extends AsyncEvents {
+    readonly plugin: ExtractPlugin<PluginTypes>;
+    /**
+     * Gets the app.
+     *
+     * @returns The app.
+     */
+    readonly app: App;
+    /**
+     * Gets the readonly default settings.
+     *
+     * @returns The default settings (as a readonly object).
+     */
+    readonly defaultSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;
+    /**
+     * Gets the current settings wrapper.
+     *
+     * @returns The current settings wrapper.
+     */
+    get settingsWrapper(): ExtractReadonlyPluginSettingsWrapper<PluginTypes>;
+    private currentSettingsWrapper;
+    private lastSavedSettingsWrapper;
+    private readonly legacySettingsConverters;
+    private readonly propertyNames;
+    private readonly validators;
+    /**
+     * Creates a new plugin settings manager.
+     *
+     * @param plugin - The plugin.
+     */
+    constructor(plugin: ExtractPlugin<PluginTypes>);
+    /**
+     * Edits the plugin settings and saves them.
+     *
+     * @param settingsEditor - The editor.
+     * @param context - The context.
+     * @returns A {@link Promise} that resolves when the settings are saved.
+     */
+    editAndSave(settingsEditor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>, context?: unknown): Promise<void>;
+    /**
+     * Ensures the settings are safe.
+     *
+     * It runs validation for each property and sets the default value if the validation fails.
+     *
+     * @param settings - The settings.
+     * @returns A {@link Promise} that resolves when the settings are safe.
+     */
+    ensureSafe(settings: ExtractPluginSettings<PluginTypes>): Promise<void>;
+    /**
+     * Gets a safe copy of the settings.
+     *
+     * @param settings - The settings.
+     * @returns A {@link Promise} that resolves to the safe copy of the settings.
+     */
+    getSafeCopy(settings: ExtractPluginSettings<PluginTypes>): Promise<ExtractPluginSettings<PluginTypes>>;
+    /**
+     * Loads the plugin settings from the file.
+     *
+     * @param isInitialLoad - Whether the settings are being loaded for the first time.
+     * @returns A {@link Promise} that resolves when the settings are loaded.
+     */
+    loadFromFile(isInitialLoad: boolean): Promise<void>;
+    /**
+     * Subscribes to the `loadSettings` event.
+     *
+     * @param name - Always `loadSettings`.
+     * @param callback - The callback to call when the event is triggered.
+     * @param thisArg - The context passed as `this` to the `callback`.
+     * @returns A reference to the event listener.
+     */
+    on(name: 'loadSettings', callback: (loadedSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>, isInitialLoad: boolean) => Promisable<void>, thisArg?: unknown): AsyncEventRef;
+    /**
+     * Subscribes to the `saveSettings` event.
+     *
+     * @param name - Always `saveSettings`.
+     * @param callback - The callback to call when the event is triggered.
+     * @param thisArg - The context passed as `this` to the `callback`.
+     * @returns A reference to the event listener.
+     */
+    on(name: 'saveSettings', callback: (newSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>, oldSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>, context: unknown) => Promisable<void>, thisArg?: unknown): AsyncEventRef;
+    /**
+     * Revalidates the settings.
+     *
+     * @returns The validation messages.
+     */
+    revalidate(): Promise<Record<ExtractPluginSettingsPropertyNames<PluginTypes>, string>>;
+    /**
+     * Saves the new plugin settings.
+     *
+     * @param context - The context of the save to file operation.
+     * @returns A {@link Promise} that resolves when the settings are saved.
+     */
+    saveToFile(context?: unknown): Promise<void>;
+    /**
+     * Sets the value of a property.
+     *
+     * @typeParam PropertyName - The name of the property.
+     * @param propertyName - The name of the property.
+     * @param value - The value to set.
+     * @returns A {@link Promise} that resolves to the validation message.
+     */
+    setProperty<PropertyName extends ExtractPluginSettingsPropertyNames<PluginTypes>>(propertyName: PropertyName, value: ExtractPluginSettings<PluginTypes>[PropertyName]): Promise<string>;
+    /**
+     * Validates the settings.
+     *
+     * @param settings - The settings.
+     * @returns A {@link Promise} that resolves to the validation result.
+     */
+    validate(settings: ExtractPluginSettings<PluginTypes>): Promise<ValidationResult<ExtractPluginSettings<PluginTypes>>>;
+    protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;
+    /**
+     * Gets the transformer.
+     *
+     * @returns The transformer.
+     */
+    protected getTransformer(): Transformer;
+    /**
+     * Called when the plugin settings are loaded.
+     *
+     * @param record - The record.
+     */
+    protected onLoadRecord(record: GenericObject): Promise<void>;
+    /**
+     * Called when the plugin settings are saving.
+     *
+     * @param _record - The record.
+     */
+    protected onSavingRecord(_record: GenericObject): Promise<void>;
+    /**
+     * Registers a legacy settings converter.
+     *
+     * @typeParam LegacySettings - The legacy settings class.
+     * @param legacySettingsClass - The legacy settings class.
+     * @param converter - The converter.
+     */
+    protected registerLegacySettingsConverter<LegacySettings extends object>(legacySettingsClass: new () => LegacySettings, converter: (legacySettings: Partial<ExtractPluginSettings<PluginTypes>> & Partial<LegacySettings>) => void): void;
+    /**
+     * Registers the legacy settings converters.
+     *
+     * This method can be overridden by subclasses to register legacy settings converters.
+     */
+    protected registerLegacySettingsConverters(): void;
+    /**
+     * Registers a validator for a property.
+     *
+     * @param propertyName - The name of the property.
+     * @param validator - The validator.
+     */
+    protected registerValidator<PropertyName extends ExtractPluginSettingsPropertyNames<PluginTypes>>(propertyName: PropertyName, validator: Validator<ExtractPluginSettings<PluginTypes>, PropertyName>): void;
+    /**
+     * Registers the validators.
+     *
+     * This method can be overridden by subclasses to register validators for properties.
+     */
+    protected registerValidators(): void;
+    private cloneSettings;
+    private cloneSettingsWrapper;
+    private createDefaultSettingsWrapper;
+    private edit;
+    private isValidPropertyName;
+    private rawRecordToSettings;
+    private saveToFileImpl;
+    private setPropertyImpl;
+    private settingsToRawRecord;
+}
+export {};

package/dist/lib/esm/obsidian/plugin/plugin-settings-manager-base.mjs

@@ -0,0 +1,384 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { AsyncEvents } from "../../async-events.mjs";
+import { getLibDebugger } from "../../debug.mjs";
+import {
+  noop,
+  noopAsync
+} from "../../function.mjs";
+import {
+  castTo,
+  deepEqual,
+  getAllKeys
+} from "../../object-utils.mjs";
+import { DateTransformer } from "../../transformers/date-transformer.mjs";
+import { DurationTransformer } from "../../transformers/duration-transformer.mjs";
+import { GroupTransformer } from "../../transformers/group-transformer.mjs";
+import { MapTransformer } from "../../transformers/map-transformer.mjs";
+import { SetTransformer } from "../../transformers/set-transformer.mjs";
+import { SkipPrivatePropertyTransformer } from "../../transformers/skip-private-property-transformer.mjs";
+import { TwoWayMapTransformer } from "../../transformers/two-way-map-transformer.mjs";
+const defaultTransformer = new GroupTransformer([
+  new SkipPrivatePropertyTransformer(),
+  new DateTransformer(),
+  new DurationTransformer(),
+  new MapTransformer(),
+  new SetTransformer(),
+  new TwoWayMapTransformer()
+]);
+class PluginSettingsManagerBase extends AsyncEvents {
+  /**
+   * Creates a new plugin settings manager.
+   *
+   * @param plugin - The plugin.
+   */
+  constructor(plugin) {
+    super();
+    this.plugin = plugin;
+    this.app = plugin.app;
+    this.defaultSettings = this.createDefaultSettings();
+    this.currentSettingsWrapper = this.createDefaultSettingsWrapper();
+    this.lastSavedSettingsWrapper = this.createDefaultSettingsWrapper();
+    this.propertyNames = getAllKeys(this.currentSettingsWrapper.settings);
+    this.registerValidators();
+    this.registerLegacySettingsConverters();
+  }
+  /**
+   * Gets the app.
+   *
+   * @returns The app.
+   */
+  app;
+  /**
+   * Gets the readonly default settings.
+   *
+   * @returns The default settings (as a readonly object).
+   */
+  defaultSettings;
+  /**
+   * Gets the current settings wrapper.
+   *
+   * @returns The current settings wrapper.
+   */
+  get settingsWrapper() {
+    return this.currentSettingsWrapper;
+  }
+  currentSettingsWrapper;
+  lastSavedSettingsWrapper;
+  legacySettingsConverters = [];
+  propertyNames;
+  validators = /* @__PURE__ */ new Map();
+  /**
+   * Edits the plugin settings and saves them.
+   *
+   * @param settingsEditor - The editor.
+   * @param context - The context.
+   * @returns A {@link Promise} that resolves when the settings are saved.
+   */
+  async editAndSave(settingsEditor, context) {
+    await this.edit(settingsEditor);
+    await this.saveToFile(context);
+  }
+  /**
+   * Ensures the settings are safe.
+   *
+   * It runs validation for each property and sets the default value if the validation fails.
+   *
+   * @param settings - The settings.
+   * @returns A {@link Promise} that resolves when the settings are safe.
+   */
+  async ensureSafe(settings) {
+    const validationResult = await this.validate(settings);
+    for (const propertyName of this.propertyNames) {
+      if (validationResult[propertyName]) {
+        settings[propertyName] = this.defaultSettings[propertyName];
+      }
+    }
+  }
+  /**
+   * Gets a safe copy of the settings.
+   *
+   * @param settings - The settings.
+   * @returns A {@link Promise} that resolves to the safe copy of the settings.
+   */
+  async getSafeCopy(settings) {
+    const safeSettings = await this.cloneSettings(settings);
+    await this.ensureSafe(safeSettings);
+    return safeSettings;
+  }
+  /**
+   * Loads the plugin settings from the file.
+   *
+   * @param isInitialLoad - Whether the settings are being loaded for the first time.
+   * @returns A {@link Promise} that resolves when the settings are loaded.
+   */
+  async loadFromFile(isInitialLoad) {
+    const data = await this.plugin.loadData();
+    this.lastSavedSettingsWrapper = this.createDefaultSettingsWrapper();
+    this.currentSettingsWrapper = this.createDefaultSettingsWrapper();
+    try {
+      if (data === void 0 || data === null) {
+        return;
+      }
+      if (typeof data !== "object") {
+        console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);
+        return;
+      }
+      const rawRecord = data;
+      const parsedSettings = await this.rawRecordToSettings(rawRecord);
+      const validationResult = await this.validate(parsedSettings);
+      for (const propertyName of this.propertyNames) {
+        this.setPropertyImpl(propertyName, parsedSettings[propertyName], validationResult[propertyName]);
+      }
+      this.lastSavedSettingsWrapper = await this.cloneSettingsWrapper(this.currentSettingsWrapper);
+      const newRecord = await this.settingsToRawRecord(this.currentSettingsWrapper.settings);
+      if (!deepEqual(newRecord, data)) {
+        await this.saveToFileImpl();
+      }
+    } finally {
+      await this.triggerAsync("loadSettings", this.currentSettingsWrapper, isInitialLoad);
+    }
+  }
+  /**
+   * Subscribes to an event.
+   *
+   * @param name - The name of the event.
+   * @param callback - The callback to call when the event is triggered.
+   * @param thisArg - The context passed as `this` to the `callback`.
+   * @returns A reference to the event listener.
+   */
+  on(name, callback, thisArg) {
+    return super.on(name, callback, thisArg);
+  }
+  /**
+   * Revalidates the settings.
+   *
+   * @returns The validation messages.
+   */
+  async revalidate() {
+    await this.edit(noop);
+    return this.currentSettingsWrapper.validationMessages;
+  }
+  /**
+   * Saves the new plugin settings.
+   *
+   * @param context - The context of the save to file operation.
+   * @returns A {@link Promise} that resolves when the settings are saved.
+   */
+  async saveToFile(context) {
+    if (deepEqual(this.lastSavedSettingsWrapper.settings, this.currentSettingsWrapper.settings)) {
+      return;
+    }
+    await this.saveToFileImpl();
+    await this.triggerAsync("saveSettings", this.currentSettingsWrapper, this.lastSavedSettingsWrapper, context);
+    this.lastSavedSettingsWrapper = await this.cloneSettingsWrapper(this.currentSettingsWrapper);
+  }
+  /**
+   * Sets the value of a property.
+   *
+   * @typeParam PropertyName - The name of the property.
+   * @param propertyName - The name of the property.
+   * @param value - The value to set.
+   * @returns A {@link Promise} that resolves to the validation message.
+   */
+  async setProperty(propertyName, value) {
+    await this.edit((settings) => {
+      settings[propertyName] = value;
+    });
+    return this.currentSettingsWrapper.validationMessages[propertyName];
+  }
+  /**
+   * Validates the settings.
+   *
+   * @param settings - The settings.
+   * @returns A {@link Promise} that resolves to the validation result.
+   */
+  async validate(settings) {
+    const result = {};
+    for (const [propertyName, validator] of this.validators.entries()) {
+      const validationMessage = await validator(settings[propertyName], settings);
+      if (validationMessage) {
+        result[propertyName] = validationMessage;
+      }
+    }
+    return result;
+  }
+  /**
+   * Gets the transformer.
+   *
+   * @returns The transformer.
+   */
+  getTransformer() {
+    return defaultTransformer;
+  }
+  /**
+   * Called when the plugin settings are loaded.
+   *
+   * @param record - The record.
+   */
+  async onLoadRecord(record) {
+    for (const converter of this.legacySettingsConverters) {
+      converter(record);
+    }
+    await Promise.resolve();
+  }
+  /**
+   * Called when the plugin settings are saving.
+   *
+   * @param _record - The record.
+   */
+  async onSavingRecord(_record) {
+    await noopAsync();
+  }
+  /**
+   * Registers a legacy settings converter.
+   *
+   * @typeParam LegacySettings - The legacy settings class.
+   * @param legacySettingsClass - The legacy settings class.
+   * @param converter - The converter.
+   */
+  registerLegacySettingsConverter(legacySettingsClass, converter) {
+    const that = this;
+    this.legacySettingsConverters.push(legacySettingsConverter);
+    function legacySettingsConverter(record) {
+      const legacySettingsKeys = new Set(Object.keys(new legacySettingsClass()));
+      const pluginSettingKeys = new Set(that.propertyNames);
+      const legacySettings = record;
+      converter(legacySettings);
+      for (const key of Object.keys(legacySettings)) {
+        if (pluginSettingKeys.has(key)) {
+          continue;
+        }
+        if (!legacySettingsKeys.has(key)) {
+          continue;
+        }
+        delete record[key];
+      }
+    }
+  }
+  /**
+   * Registers the legacy settings converters.
+   *
+   * This method can be overridden by subclasses to register legacy settings converters.
+   */
+  registerLegacySettingsConverters() {
+    noop();
+  }
+  /**
+   * Registers a validator for a property.
+   *
+   * @param propertyName - The name of the property.
+   * @param validator - The validator.
+   */
+  registerValidator(propertyName, validator) {
+    this.validators.set(propertyName, validator);
+  }
+  /**
+   * Registers the validators.
+   *
+   * This method can be overridden by subclasses to register validators for properties.
+   */
+  registerValidators() {
+    noop();
+  }
+  async cloneSettings(settings) {
+    const record = await this.settingsToRawRecord(settings);
+    const json = JSON.stringify(record);
+    const cloneRecord = JSON.parse(json);
+    return await this.rawRecordToSettings(cloneRecord);
+  }
+  async cloneSettingsWrapper(settingsWrapper) {
+    return {
+      safeSettings: await this.cloneSettings(settingsWrapper.safeSettings),
+      settings: await this.cloneSettings(settingsWrapper.settings),
+      validationMessages: { ...settingsWrapper.validationMessages }
+    };
+  }
+  createDefaultSettingsWrapper() {
+    return {
+      safeSettings: this.createDefaultSettings(),
+      settings: this.createDefaultSettings(),
+      validationMessages: castTo({})
+    };
+  }
+  async edit(settingsEditor) {
+    try {
+      await settingsEditor(this.currentSettingsWrapper.settings);
+    } finally {
+      const validationResult = await this.validate(this.currentSettingsWrapper.settings);
+      for (const propertyName of this.propertyNames) {
+        const validationMessage = validationResult[propertyName] ?? "";
+        this.currentSettingsWrapper.validationMessages[propertyName] = validationMessage;
+        this.currentSettingsWrapper.safeSettings[propertyName] = validationMessage ? this.defaultSettings[propertyName] : this.currentSettingsWrapper.settings[propertyName];
+      }
+    }
+  }
+  isValidPropertyName(prop) {
+    if (typeof prop !== "string") {
+      return false;
+    }
+    return this.propertyNames.includes(prop);
+  }
+  async rawRecordToSettings(rawRecord) {
+    rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);
+    await this.onLoadRecord(rawRecord);
+    const settings = this.createDefaultSettings();
+    for (const [propertyName, value] of Object.entries(rawRecord)) {
+      if (!this.isValidPropertyName(propertyName)) {
+        getLibDebugger("PluginSettingsManagerBase:rawRecordToSettings")(`Unknown property: ${propertyName}`);
+        continue;
+      }
+      if (typeof value !== typeof this.defaultSettings[propertyName]) {
+        getLibDebugger("PluginSettingsManagerBase:rawRecordToSettings")(
+          "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.",
+          {
+            defaultValue: this.defaultSettings[propertyName],
+            propertyName,
+            value
+          }
+        );
+      }
+      settings[propertyName] = value;
+    }
+    return settings;
+  }
+  async saveToFileImpl() {
+    await this.plugin.saveData(await this.settingsToRawRecord(this.currentSettingsWrapper.settings));
+  }
+  setPropertyImpl(propertyName, value, validationMessage) {
+    this.currentSettingsWrapper.settings[propertyName] = value;
+    this.currentSettingsWrapper.validationMessages[propertyName] = validationMessage ?? "";
+    this.currentSettingsWrapper.safeSettings[propertyName] = validationMessage ? this.defaultSettings[propertyName] : value;
+  }
+  async settingsToRawRecord(settings) {
+    const rawRecord = {};
+    for (const propertyName of this.propertyNames) {
+      rawRecord[propertyName] = settings[propertyName];
+    }
+    await this.onSavingRecord(rawRecord);
+    return this.getTransformer().transformObjectRecursively(rawRecord);
+  }
+}
+export {
+  PluginSettingsManagerBase
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin-settings-manager-base.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Plugin settings manager base class.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type { App } from 'obsidian';\nimport type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type { AsyncEventRef } from '../../async-events.ts';\nimport type { Transformer } from '../../transformers/transformer.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../type.ts';\nimport type { PluginSettingsWrapper } from './plugin-settings-wrapper.ts';\nimport type {\n  ExtractPlugin,\n  ExtractPluginSettings,\n  ExtractPluginSettingsPropertyNames,\n  ExtractPluginSettingsPropertyValues,\n  ExtractPluginSettingsWrapper,\n  ExtractReadonlyPluginSettingsWrapper,\n  PluginTypesBase\n} from './plugin-types-base.ts';\n\nimport { AsyncEvents } from '../../async-events.ts';\nimport { getLibDebugger } from '../../debug.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport {\n  castTo,\n  deepEqual,\n  getAllKeys\n} from '../../object-utils.ts';\nimport { DateTransformer } from '../../transformers/date-transformer.ts';\nimport { DurationTransformer } from '../../transformers/duration-transformer.ts';\nimport { GroupTransformer } from '../../transformers/group-transformer.ts';\nimport { MapTransformer } from '../../transformers/map-transformer.ts';\nimport { SetTransformer } from '../../transformers/set-transformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../transformers/skip-private-property-transformer.ts';\nimport { TwoWayMapTransformer } from '../../transformers/two-way-map-transformer.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\ntype ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;\n\ntype Validator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<string>>;\n\n/**\n * Base class for managing plugin settings.\n *\n * @typeParam PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginSettingsManagerBase<PluginTypes extends PluginTypesBase> extends AsyncEvents {\n  /**\n   * Gets the app.\n   *\n   * @returns The app.\n   */\n  public readonly app: App;\n\n  /**\n   * Gets the readonly default settings.\n   *\n   * @returns The default settings (as a readonly object).\n   */\n  public readonly defaultSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n\n  /**\n   * Gets the current settings wrapper.\n   *\n   * @returns The current settings wrapper.\n   */\n  public get settingsWrapper(): ExtractReadonlyPluginSettingsWrapper<PluginTypes> {\n    return this.currentSettingsWrapper as ExtractReadonlyPluginSettingsWrapper<PluginTypes>;\n  }\n\n  private currentSettingsWrapper: ExtractPluginSettingsWrapper<PluginTypes>;\n  private lastSavedSettingsWrapper: ExtractPluginSettingsWrapper<PluginTypes>;\n  private readonly legacySettingsConverters: ((record: GenericObject) => void)[] = [];\n  private readonly propertyNames: ExtractPluginSettingsPropertyNames<PluginTypes>[];\n  private readonly validators = new Map<ExtractPluginSettingsPropertyNames<PluginTypes>, Validator<ExtractPluginSettings<PluginTypes>>>();\n\n  /**\n   * Creates a new plugin settings manager.\n   *\n   * @param plugin - The plugin.\n   */\n  public constructor(public readonly plugin: ExtractPlugin<PluginTypes>) {\n    super();\n    this.app = plugin.app;\n    this.defaultSettings = this.createDefaultSettings() as ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n    this.currentSettingsWrapper = this.createDefaultSettingsWrapper();\n    this.lastSavedSettingsWrapper = this.createDefaultSettingsWrapper();\n    this.propertyNames = getAllKeys(this.currentSettingsWrapper.settings);\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: ExtractPluginSettings<PluginTypes>) => Promisable<void>, context?: unknown): Promise<void> {\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: ExtractPluginSettings<PluginTypes>): Promise<void> {\n    const validationResult = await this.validate(settings);\n    for (const propertyName of this.propertyNames) {\n      if (validationResult[propertyName]) {\n        settings[propertyName] = this.defaultSettings[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: ExtractPluginSettings<PluginTypes>): Promise<ExtractPluginSettings<PluginTypes>> {\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.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    const data = await this.plugin.loadData() as unknown;\n    this.lastSavedSettingsWrapper = this.createDefaultSettingsWrapper();\n    this.currentSettingsWrapper = this.createDefaultSettingsWrapper();\n\n    try {\n      if (data === undefined || data === null) {\n        return;\n      }\n\n      if (typeof data !== 'object') {\n        console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);\n        return;\n      }\n\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(propertyName, parsedSettings[propertyName], validationResult[propertyName]);\n      }\n\n      this.lastSavedSettingsWrapper = await this.cloneSettingsWrapper(this.currentSettingsWrapper);\n\n      const newRecord = await this.settingsToRawRecord(this.currentSettingsWrapper.settings);\n\n      if (!deepEqual(newRecord, data)) {\n        await this.saveToFileImpl();\n      }\n    } finally {\n      await this.triggerAsync('loadSettings', this.currentSettingsWrapper, isInitialLoad);\n    }\n  }\n\n  /**\n   * Subscribes to the `loadSettings` event.\n   *\n   * @param name - Always `loadSettings`.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   */\n  public override on(\n    name: 'loadSettings',\n    callback: (\n      loadedSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n      isInitialLoad: boolean\n    ) => Promisable<void>,\n    thisArg?: unknown\n  ): AsyncEventRef;\n  /**\n   * Subscribes to the `saveSettings` event.\n   *\n   * @param name - Always `saveSettings`.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   */\n  public override on(\n    name: 'saveSettings',\n    callback: (\n      newSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n      oldSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n      context: unknown\n    ) => Promisable<void>,\n    thisArg?: unknown\n  ): AsyncEventRef;\n  /**\n   * Subscribes to an event.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   */\n  public override on<Args extends unknown[]>(\n    name: string,\n    callback: (...args: Args) => Promisable<void>,\n    thisArg?: unknown\n  ): AsyncEventRef {\n    return super.on(name, callback, thisArg);\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns The validation messages.\n   */\n  public async revalidate(): Promise<Record<ExtractPluginSettingsPropertyNames<PluginTypes>, string>> {\n    await this.edit(noop);\n    return this.currentSettingsWrapper.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    if (deepEqual(this.lastSavedSettingsWrapper.settings, this.currentSettingsWrapper.settings)) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.triggerAsync('saveSettings', this.currentSettingsWrapper, this.lastSavedSettingsWrapper, context);\n    this.lastSavedSettingsWrapper = await this.cloneSettingsWrapper(this.currentSettingsWrapper);\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 ExtractPluginSettingsPropertyNames<PluginTypes>>(\n    propertyName: PropertyName,\n    value: ExtractPluginSettings<PluginTypes>[PropertyName]\n  ): Promise<string> {\n    await this.edit((settings) => {\n      settings[propertyName] = value;\n    });\n    return this.currentSettingsWrapper.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: ExtractPluginSettings<PluginTypes>): Promise<ValidationResult<ExtractPluginSettings<PluginTypes>>> {\n    const result: ValidationResult<ExtractPluginSettings<PluginTypes>> = {};\n    for (const [propertyName, validator] of this.validators.entries()) {\n      const validationMessage = await validator(settings[propertyName], settings);\n      if (validationMessage) {\n        result[propertyName] = validationMessage;\n      }\n    }\n\n    return result;\n  }\n\n  protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;\n\n  /**\n   * Gets the transformer.\n   *\n   * @returns The transformer.\n   */\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  /**\n   * Called when the plugin settings are loaded.\n   *\n   * @param record - The record.\n   */\n  protected async onLoadRecord(record: GenericObject): Promise<void> {\n    for (const converter of this.legacySettingsConverters) {\n      converter(record);\n    }\n    await Promise.resolve();\n  }\n\n  /**\n   * Called when the plugin settings are saving.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers a 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  protected registerLegacySettingsConverter<LegacySettings extends object>(\n    legacySettingsClass: new () => LegacySettings,\n    converter: (legacySettings: Partial<ExtractPluginSettings<PluginTypes>> & Partial<LegacySettings>) => void\n  ): void {\n    const that = 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>(that.propertyNames);\n      const legacySettings = record as Partial<ExtractPluginSettings<PluginTypes>> & Partial<LegacySettings>;\n      converter(legacySettings);\n      for (const key of Object.keys(legacySettings)) {\n        if (pluginSettingKeys.has(key)) {\n          continue;\n        }\n\n        if (!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 the legacy settings converters.\n   *\n   * This method can be overridden by subclasses to register legacy settings converters.\n   */\n  protected registerLegacySettingsConverters(): void {\n    noop();\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  protected registerValidator<PropertyName extends ExtractPluginSettingsPropertyNames<PluginTypes>>(\n    propertyName: PropertyName,\n    validator: Validator<ExtractPluginSettings<PluginTypes>, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as Validator<ExtractPluginSettings<PluginTypes>>);\n  }\n\n  /**\n   * Registers the validators.\n   *\n   * This method can be overridden by subclasses to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private async cloneSettings(settings: ExtractPluginSettings<PluginTypes>): Promise<ExtractPluginSettings<PluginTypes>> {\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 cloneSettingsWrapper(\n    settingsWrapper: PluginSettingsWrapper<ExtractPluginSettings<PluginTypes>>\n  ): Promise<PluginSettingsWrapper<ExtractPluginSettings<PluginTypes>>> {\n    return {\n      safeSettings: await this.cloneSettings(settingsWrapper.safeSettings),\n      settings: await this.cloneSettings(settingsWrapper.settings),\n      validationMessages: { ...settingsWrapper.validationMessages }\n    };\n  }\n\n  private createDefaultSettingsWrapper(): PluginSettingsWrapper<ExtractPluginSettings<PluginTypes>> {\n    return {\n      safeSettings: this.createDefaultSettings(),\n      settings: this.createDefaultSettings(),\n      validationMessages: castTo<Record<ExtractPluginSettingsPropertyNames<PluginTypes>, string>>({})\n    };\n  }\n\n  private async edit(settingsEditor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>): Promise<void> {\n    try {\n      await settingsEditor(this.currentSettingsWrapper.settings);\n    } finally {\n      const validationResult = await this.validate(this.currentSettingsWrapper.settings);\n      for (const propertyName of this.propertyNames) {\n        const validationMessage = validationResult[propertyName] ?? '';\n        this.currentSettingsWrapper.validationMessages[propertyName] = validationMessage;\n        this.currentSettingsWrapper.safeSettings[propertyName] = validationMessage\n          ? this.defaultSettings[propertyName]\n          : this.currentSettingsWrapper.settings[propertyName];\n      }\n    }\n  }\n\n  private isValidPropertyName(prop: unknown): prop is ExtractPluginSettingsPropertyNames<PluginTypes> {\n    if (typeof prop !== 'string') {\n      return false;\n    }\n\n    return (this.propertyNames as string[]).includes(prop);\n  }\n\n  private async rawRecordToSettings(rawRecord: GenericObject): Promise<ExtractPluginSettings<PluginTypes>> {\n    rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);\n    await this.onLoadRecord(rawRecord);\n\n    const settings = this.createDefaultSettings();\n\n    for (const [propertyName, value] of Object.entries(rawRecord)) {\n      if (!this.isValidPropertyName(propertyName)) {\n        getLibDebugger('PluginSettingsManagerBase:rawRecordToSettings')(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof this.defaultSettings[propertyName]) {\n        getLibDebugger('PluginSettingsManagerBase: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: this.defaultSettings[propertyName],\n            propertyName,\n            value\n          }\n        );\n      }\n\n      settings[propertyName] = value as ExtractPluginSettingsPropertyValues<PluginTypes>;\n    }\n\n    return settings;\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.plugin.saveData(await this.settingsToRawRecord(this.currentSettingsWrapper.settings));\n  }\n\n  private setPropertyImpl(\n    propertyName: ExtractPluginSettingsPropertyNames<PluginTypes>,\n    value: ExtractPluginSettingsPropertyValues<PluginTypes>,\n    validationMessage?: string\n  ): void {\n    this.currentSettingsWrapper.settings[propertyName] = value;\n    this.currentSettingsWrapper.validationMessages[propertyName] = validationMessage ?? '';\n    this.currentSettingsWrapper.safeSettings[propertyName] = validationMessage ? this.defaultSettings[propertyName] : value;\n  }\n\n  private async settingsToRawRecord(settings: ExtractPluginSettings<PluginTypes>): 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/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}
