obsidian-dev-utils 22.1.1-beta.3 → 22.1.1-beta.5

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

@@ -5,42 +5,94 @@ if you want to view the source, please visit the github repository of this plugi
 
 (function initEsm(){if(globalThis.process){return}const browserProcess={browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"};globalThis.process=browserProcess})();
 
-import { Plugin } from "obsidian";
-import {
-  noop,
-  noopAsync
-} from "../../Function.mjs";
+import { noop } from "../../Function.mjs";
 import { DateTransformer } from "../../Transformers/DateTransformer.mjs";
 import { DurationTransformer } from "../../Transformers/DurationTransformer.mjs";
 import { GroupTransformer } from "../../Transformers/GroupTransformer.mjs";
 import { SkipPrivatePropertyTransformer } from "../../Transformers/SkipPrivatePropertyTransformer.mjs";
+import { isValidationMessageHolder } from "../ValidationMessage.mjs";
 const defaultTransformer = new GroupTransformer([
   new SkipPrivatePropertyTransformer(),
   new DateTransformer(),
   new DurationTransformer()
 ]);
+class ProxyHandlerBase {
+  constructor(properties) {
+    this.properties = properties;
+  }
+  get(target, prop) {
+    const record = target;
+    if (typeof prop !== "string") {
+      return record[prop];
+    }
+    const propertyObj = this.properties.get(prop);
+    if (!propertyObj) {
+      return record[prop];
+    }
+    return this.getPropertyValue(propertyObj);
+  }
+}
+class EditableSettingsProxyHandler extends ProxyHandlerBase {
+  validationPromise = Promise.resolve();
+  set(target, prop, value) {
+    const record = target;
+    if (typeof prop !== "string") {
+      record[prop] = value;
+      return true;
+    }
+    const propertyObj = this.properties.get(prop);
+    if (!propertyObj) {
+      record[prop] = value;
+      return true;
+    }
+    propertyObj.set(value);
+    this.validationPromise = this.validationPromise.then(() => propertyObj.setAndValidate(value));
+    return true;
+  }
+  getPropertyValue(propertyObj) {
+    return propertyObj.get();
+  }
+}
 class PluginSettingsProperty {
   constructor(defaultValue, validator) {
     this.defaultValue = defaultValue;
     this.validator = validator;
   }
-  validationMessage = "";
+  get validationMessage() {
+    return this._validationMessage;
+  }
+  _validationMessage = "";
+  savedValue;
   value;
   clear() {
     this.value = void 0;
-    this.validationMessage = "";
+    this._validationMessage = "";
   }
   get() {
     return this.value ?? this.defaultValue;
   }
   getSafe() {
-    return this.validationMessage ? this.defaultValue : this.get();
+    return this._validationMessage ? this.defaultValue : this.get();
+  }
+  getSaved() {
+    return this.savedValue;
+  }
+  save() {
+    this.savedValue = this.value;
+  }
+  set(value) {
+    if (isValidationMessageHolder(value)) {
+      this._validationMessage = value.validationMessage;
+    } else {
+      this.value = value;
+    }
   }
-  async set(value) {
-    this.value = value;
-    if (this.value !== void 0) {
-      this.validationMessage = await this.validator(this.value) ?? "";
+  async setAndValidate(value) {
+    this.set(value);
+    if (this.value === void 0) {
+      return;
     }
+    this._validationMessage = await this.validator(this.value) ?? "";
   }
 }
 class PropertiesMap extends Map {
@@ -55,30 +107,34 @@ class PropertiesMap extends Map {
     return super.set(key, value);
   }
 }
+class SafeSettingsProxyHandler extends ProxyHandlerBase {
+  getPropertyValue(propertyObj) {
+    return propertyObj.getSafe();
+  }
+}
 class PluginSettingsManagerBase {
   constructor(plugin) {
     this.plugin = plugin;
-    const defaultSettings = this.createDefaultSettings();
+    this.defaultSettings = this.createDefaultSettings();
     this.addValidators();
     this.properties = new PropertiesMap();
-    for (const key of Object.keys(defaultSettings)) {
-      this.properties.set(key, new PluginSettingsProperty(defaultSettings[key], this.validators.get(key) ?? noop));
+    for (const key of Object.keys(this.defaultSettings)) {
+      this.properties.set(key, new PluginSettingsProperty(this.defaultSettings[key], this.validators.get(key) ?? noop));
     }
     this.validators.clear();
-    this.safeSettings = new Proxy(defaultSettings, {
-      get: (_target, prop) => {
-        if (typeof prop !== "string") {
-          return void 0;
-        }
-        return this.properties.get(prop);
-      }
-    });
-    this.addValidators();
+    this.safeSettings = new Proxy(this.defaultSettings, new SafeSettingsProxyHandler(this.properties));
   }
   safeSettings;
+  defaultSettings;
   properties;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   validators = /* @__PURE__ */ new Map();
+  async editAndSave(editor) {
+    const editableSettings = new Proxy(this.defaultSettings, new EditableSettingsProxyHandler(this.properties));
+    await editor(editableSettings);
+    await editableSettings.validationPromise;
+    await this.saveToFile();
+  }
   getProperty(property) {
     return this.properties.getTyped(property);
   }
@@ -97,7 +153,9 @@ class PluginSettingsManagerBase {
     }
     let record = data;
     record = this.getTransformer().transformObjectRecursively(record);
+    const beforePrepareJson = JSON.stringify(record);
     await this.prepareRecord(record);
+    const afterPrepareJson = JSON.stringify(record);
     for (const [key, value] of Object.entries(record)) {
       const propertyObj = this.properties.get(key);
       if (!propertyObj) {
@@ -108,7 +166,10 @@ class PluginSettingsManagerBase {
         console.warn(`Invalid value type. Expected ${typeof propertyObj.defaultValue}, got: ${typeof value}`);
         continue;
       }
-      await propertyObj.set(value);
+      await propertyObj.setAndValidate(value);
+    }
+    if (afterPrepareJson !== beforePrepareJson) {
+      await this.saveToFile();
     }
   }
   /**
@@ -117,12 +178,13 @@ class PluginSettingsManagerBase {
    * @returns A promise that resolves when the settings are saved.
    */
   async saveToFile() {
-    const record = this.getTransformer().transformObjectRecursively(this.getSettings());
+    const oldSettings = this.getSavedSettings();
+    for (const property of this.properties.values()) {
+      property.save();
+    }
+    const record = this.getTransformer().transformObjectRecursively(this.getSettingsRecord());
     await this.plugin.saveData(record);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  async validate(_property, _value) {
-    await noopAsync();
+    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings);
   }
   addValidator(property, validator) {
     this.validators.set(property, validator);
@@ -133,10 +195,19 @@ class PluginSettingsManagerBase {
   getTransformer() {
     return defaultTransformer;
   }
-  async prepareRecord(_record) {
-    await noopAsync();
+  prepareRecord(_record) {
+    noop();
+  }
+  getSavedSettings() {
+    const savedSettings = {};
+    for (const [key, property] of this.properties.entries()) {
+      savedSettings[key] = property.getSaved();
+    }
+    const proto = Object.getPrototypeOf(this.defaultSettings);
+    Object.setPrototypeOf(savedSettings, proto);
+    return savedSettings;
   }
-  getSettings() {
+  getSettingsRecord() {
     const settings = {};
     for (const [key, property] of this.properties.entries()) {
       settings[key] = property.get();
@@ -147,4 +218,4 @@ class PluginSettingsManagerBase {
 export {
   PluginSettingsManagerBase
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["import type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport { Plugin } from 'obsidian';\n\nimport type { StringKeys } from '../../Object.ts';\nimport type { Transformer } from '../../Transformers/Transformer.ts';\n\nimport {\n  noop,\n  noopAsync\n} from '../../Function.ts';\nimport { DateTransformer } from '../../Transformers/DateTransformer.ts';\nimport { DurationTransformer } from '../../Transformers/DurationTransformer.ts';\nimport { GroupTransformer } from '../../Transformers/GroupTransformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../Transformers/SkipPrivatePropertyTransformer.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer()\n]);\n\n// eslint-disable-next-line @typescript-eslint/no-invalid-void-type\ntype Validator<T> = (value: T) => Promisable<string | void>;\n\nclass PluginSettingsProperty<T> {\n  public validationMessage = '';\n  private value: T | undefined;\n\n  public constructor(public readonly defaultValue: T, private readonly validator: Validator<T>) {}\n\n  public clear(): void {\n    this.value = undefined;\n    this.validationMessage = '';\n  }\n\n  public get(): T {\n    return this.value ?? this.defaultValue;\n  }\n\n  public getSafe(): T {\n    return this.validationMessage ? this.defaultValue : this.get();\n  }\n\n  public async set(value: T | undefined): Promise<void> {\n    this.value = value;\n    if (this.value !== undefined) {\n      this.validationMessage = (await this.validator(this.value) as string | undefined) ?? '';\n    }\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nclass PropertiesMap<PluginSettings extends object> extends Map<string, PluginSettingsProperty<any>> {\n  public getTyped<Property extends StringKeys<PluginSettings>>(key: Property): PluginSettingsProperty<PluginSettings[Property]> {\n    const property = super.get(key);\n    if (!property) {\n      throw new Error(`Property ${String(key)} not found`);\n    }\n\n    return property as PluginSettingsProperty<PluginSettings[Property]>;\n  }\n\n  public setTyped<Property extends StringKeys<PluginSettings>>(key: Property, value: PluginSettingsProperty<PluginSettings[Property]>): this {\n    return super.set(key, value);\n  }\n}\n\n/**\n * Base class for managing plugin settings.\n *\n * @typeParam PluginSettings - The type representing the plugin settings object.\n */\nexport abstract class PluginSettingsManagerBase<PluginSettings extends object> {\n  public readonly safeSettings: ReadonlyDeep<PluginSettings>;\n\n  private properties: PropertiesMap<PluginSettings>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private validators: Map<string, Validator<any>> = new Map<string, Validator<any>>();\n\n  public constructor(private plugin: Plugin) {\n    const defaultSettings = this.createDefaultSettings();\n\n    this.addValidators();\n\n    this.properties = new PropertiesMap<PluginSettings>();\n\n    for (const key of Object.keys(defaultSettings) as StringKeys<PluginSettings>[]) {\n      this.properties.set(key, new PluginSettingsProperty(defaultSettings[key], this.validators.get(key) ?? noop));\n    }\n\n    this.validators.clear();\n\n    this.safeSettings = new Proxy(defaultSettings, {\n      get: (_target, prop): unknown => {\n        if (typeof prop !== 'string') {\n          return undefined;\n        }\n\n        return this.properties.get(prop);\n      }\n    }) as ReadonlyDeep<PluginSettings>;\n\n    this.addValidators();\n  }\n\n  public getProperty<Property extends StringKeys<PluginSettings>>(property: Property): PluginSettingsProperty<PluginSettings[Property]> {\n    return this.properties.getTyped(property);\n  }\n\n  public async loadFromFile(): Promise<void> {\n    for (const property of this.properties.values()) {\n      property.clear();\n    }\n\n    const data = await this.plugin.loadData() as unknown;\n\n    if (data === undefined || data === null) {\n      return;\n    }\n\n    if (typeof data !== 'object' || Array.isArray(data)) {\n      const type = Array.isArray(data) ? 'Array' : typeof data;\n      console.error(`Invalid data type. Expected Object, got: ${type}`);\n      return;\n    }\n\n    let record = data as Record<string, unknown>;\n    record = this.getTransformer().transformObjectRecursively(record);\n    await this.prepareRecord(record);\n\n    for (const [key, value] of Object.entries(record)) {\n      const propertyObj = this.properties.get(key);\n      if (!propertyObj) {\n        console.warn(`Unknown property: ${key}`);\n        continue;\n      }\n\n      if (typeof value !== typeof propertyObj.defaultValue) {\n        console.warn(`Invalid value type. Expected ${typeof propertyObj.defaultValue}, got: ${typeof value}`);\n        continue;\n      }\n\n      await propertyObj.set(value as PluginSettings[StringKeys<PluginSettings>]);\n    }\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @returns A promise that resolves when the settings are saved.\n   */\n  public async saveToFile(): Promise<void> {\n    const record = this.getTransformer().transformObjectRecursively(this.getSettings());\n    await this.plugin.saveData(record);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type\n  public async validate<Property extends StringKeys<PluginSettings>>(_property: Property, _value: PluginSettings[Property]): Promise<string | void> {\n    await noopAsync();\n  }\n\n  protected addValidator<Property extends StringKeys<PluginSettings>>(property: Property, validator: Validator<PluginSettings[Property]>): void {\n    this.validators.set(property, validator);\n  }\n\n  protected addValidators(): void {\n    noop();\n  }\n\n  protected abstract createDefaultSettings(): PluginSettings;\n\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  protected async prepareRecord(_record: Record<string, unknown>): Promise<void> {\n    await noopAsync();\n  }\n\n  private getSettings(): Record<StringKeys<PluginSettings>, unknown> {\n    const settings: Record<StringKeys<PluginSettings>, unknown> = {} as Record<StringKeys<PluginSettings>, unknown>;\n    for (const [key, property] of this.properties.entries()) {\n      settings[key as StringKeys<PluginSettings>] = property.get() as unknown;\n    }\n\n    return settings;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["import type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../Object.ts';\nimport type { Transformer } from '../../Transformers/Transformer.ts';\nimport type { ValidationMessageHolder } from '../ValidationMessage.ts';\nimport type { PluginBase } from './PluginBase.ts';\n\nimport { noop } from '../../Function.ts';\nimport { DateTransformer } from '../../Transformers/DateTransformer.ts';\nimport { DurationTransformer } from '../../Transformers/DurationTransformer.ts';\nimport { GroupTransformer } from '../../Transformers/GroupTransformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../Transformers/SkipPrivatePropertyTransformer.ts';\nimport { isValidationMessageHolder } from '../ValidationMessage.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer()\n]);\n\ntype Validator<T> = (value: T) => Promisable<MaybeReturn<string>>;\n\nabstract class ProxyHandlerBase<PluginSettings extends object> implements ProxyHandler<PluginSettings> {\n  public constructor(protected readonly properties: PropertiesMap<PluginSettings>) {}\n\n  public get(target: PluginSettings, prop: string | symbol): unknown {\n    const record = target as Record<string | symbol, unknown>;\n    if (typeof prop !== 'string') {\n      return record[prop];\n    }\n\n    const propertyObj = this.properties.get(prop);\n    if (!propertyObj) {\n      return record[prop];\n    }\n\n    return this.getPropertyValue(propertyObj);\n  }\n\n  protected abstract getPropertyValue(propertyObj: PluginSettingsProperty<unknown>): unknown;\n}\n\nclass EditableSettingsProxyHandler<PluginSettings extends object> extends ProxyHandlerBase<PluginSettings> {\n  private validationPromise = Promise.resolve();\n  public set(target: PluginSettings, prop: string | symbol, value: unknown): boolean {\n    const record = target as Record<string | symbol, unknown>;\n\n    if (typeof prop !== 'string') {\n      record[prop] = value;\n      return true;\n    }\n\n    const propertyObj = this.properties.get(prop);\n    if (!propertyObj) {\n      record[prop] = value;\n      return true;\n    }\n\n    propertyObj.set(value);\n    this.validationPromise = this.validationPromise.then(() => propertyObj.setAndValidate(value));\n\n    return true;\n  }\n\n  protected override getPropertyValue(propertyObj: PluginSettingsProperty<unknown>): unknown {\n    return propertyObj.get();\n  }\n}\n\nclass PluginSettingsProperty<T> {\n  public get validationMessage(): string {\n    return this._validationMessage;\n  }\n\n  private _validationMessage = '';\n\n  private savedValue: T | undefined;\n\n  private value: T | undefined;\n  public constructor(public readonly defaultValue: T, private readonly validator: Validator<T>) {}\n\n  public clear(): void {\n    this.value = undefined;\n    this._validationMessage = '';\n  }\n\n  public get(): T {\n    return this.value ?? this.defaultValue;\n  }\n\n  public getSafe(): T {\n    return this._validationMessage ? this.defaultValue : this.get();\n  }\n\n  public getSaved(): T | undefined {\n    return this.savedValue;\n  }\n\n  public save(): void {\n    this.savedValue = this.value;\n  }\n\n  public set(value: T | undefined | ValidationMessageHolder): void {\n    if (isValidationMessageHolder(value)) {\n      this._validationMessage = value.validationMessage;\n    } else {\n      this.value = value;\n    }\n  }\n\n  public async setAndValidate(value: T | undefined | ValidationMessageHolder): Promise<void> {\n    this.set(value);\n    if (this.value === undefined) {\n      return;\n    }\n\n    this._validationMessage = (await this.validator(this.value) as string | undefined) ?? '';\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nclass PropertiesMap<PluginSettings extends object> extends Map<string, PluginSettingsProperty<any>> {\n  public getTyped<Property extends StringKeys<PluginSettings>>(key: Property): PluginSettingsProperty<PluginSettings[Property]> {\n    const property = super.get(key);\n    if (!property) {\n      throw new Error(`Property ${String(key)} not found`);\n    }\n\n    return property as PluginSettingsProperty<PluginSettings[Property]>;\n  }\n\n  public setTyped<Property extends StringKeys<PluginSettings>>(key: Property, value: PluginSettingsProperty<PluginSettings[Property]>): this {\n    return super.set(key, value);\n  }\n}\n\nclass SafeSettingsProxyHandler<PluginSettings extends object> extends ProxyHandlerBase<PluginSettings> {\n  protected override getPropertyValue(propertyObj: PluginSettingsProperty<unknown>): unknown {\n    return propertyObj.getSafe();\n  }\n}\n\n/**\n * Base class for managing plugin settings.\n *\n * @typeParam PluginSettings - The type representing the plugin settings object.\n */\nexport abstract class PluginSettingsManagerBase<PluginSettings extends object> {\n  public readonly safeSettings: ReadonlyDeep<PluginSettings>;\n\n  private defaultSettings: PluginSettings;\n  private properties: PropertiesMap<PluginSettings>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private validators: Map<string, Validator<any>> = new Map<string, Validator<any>>();\n\n  public constructor(private plugin: PluginBase<PluginSettings>) {\n    this.defaultSettings = this.createDefaultSettings();\n\n    this.addValidators();\n\n    this.properties = new PropertiesMap<PluginSettings>();\n\n    for (const key of Object.keys(this.defaultSettings) as StringKeys<PluginSettings>[]) {\n      this.properties.set(key, new PluginSettingsProperty(this.defaultSettings[key], this.validators.get(key) ?? noop));\n    }\n\n    this.validators.clear();\n\n    this.safeSettings = new Proxy(this.defaultSettings, new SafeSettingsProxyHandler<PluginSettings>(this.properties)) as ReadonlyDeep<PluginSettings>;\n  }\n\n  public async editAndSave(editor: (settings: PluginSettings) => Promisable<void>): Promise<void> {\n    const editableSettings = new Proxy(this.defaultSettings, new EditableSettingsProxyHandler<PluginSettings>(this.properties)) as {\n      validationPromise: Promise<void>;\n    } & PluginSettings;\n    await editor(editableSettings);\n    await editableSettings.validationPromise;\n    await this.saveToFile();\n  }\n\n  public getProperty<Property extends StringKeys<PluginSettings>>(property: Property): PluginSettingsProperty<PluginSettings[Property]> {\n    return this.properties.getTyped(property);\n  }\n\n  public async loadFromFile(): Promise<void> {\n    for (const property of this.properties.values()) {\n      property.clear();\n    }\n\n    const data = await this.plugin.loadData() as unknown;\n\n    if (data === undefined || data === null) {\n      return;\n    }\n\n    if (typeof data !== 'object' || Array.isArray(data)) {\n      const type = Array.isArray(data) ? 'Array' : typeof data;\n      console.error(`Invalid data type. Expected Object, got: ${type}`);\n      return;\n    }\n\n    let record = data as Record<string, unknown>;\n    record = this.getTransformer().transformObjectRecursively(record);\n    const beforePrepareJson = JSON.stringify(record);\n    await this.prepareRecord(record);\n    const afterPrepareJson = JSON.stringify(record);\n\n    for (const [key, value] of Object.entries(record)) {\n      const propertyObj = this.properties.get(key);\n      if (!propertyObj) {\n        console.warn(`Unknown property: ${key}`);\n        continue;\n      }\n\n      if (typeof value !== typeof propertyObj.defaultValue) {\n        console.warn(`Invalid value type. Expected ${typeof propertyObj.defaultValue}, got: ${typeof value}`);\n        continue;\n      }\n\n      await propertyObj.setAndValidate(value);\n    }\n\n    if (afterPrepareJson !== beforePrepareJson) {\n      await this.saveToFile();\n    }\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @returns A promise that resolves when the settings are saved.\n   */\n  public async saveToFile(): Promise<void> {\n    const oldSettings = this.getSavedSettings();\n\n    for (const property of this.properties.values()) {\n      property.save();\n    }\n\n    const record = this.getTransformer().transformObjectRecursively(this.getSettingsRecord());\n    await this.plugin.saveData(record);\n\n    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings);\n  }\n\n  protected addValidator<Property extends StringKeys<PluginSettings>>(property: Property, validator: Validator<PluginSettings[Property]>): void {\n    this.validators.set(property, validator);\n  }\n\n  protected addValidators(): void {\n    noop();\n  }\n\n  protected abstract createDefaultSettings(): PluginSettings;\n\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  protected prepareRecord(_record: Record<string, unknown>): Promisable<void> {\n    noop();\n  }\n\n  private getSavedSettings(): Partial<PluginSettings> {\n    const savedSettings: Partial<PluginSettings> = {};\n    for (const [key, property] of this.properties.entries()) {\n      savedSettings[key as StringKeys<PluginSettings>] = property.getSaved() as PluginSettings[StringKeys<PluginSettings>] | undefined;\n    }\n    const proto = Object.getPrototypeOf(this.defaultSettings) as object;\n    Object.setPrototypeOf(savedSettings, proto);\n    return savedSettings;\n  }\n\n  private getSettingsRecord(): Record<StringKeys<PluginSettings>, unknown> {\n    const settings: Record<StringKeys<PluginSettings>, unknown> = {} as Record<StringKeys<PluginSettings>, unknown>;\n    for (const [key, property] of this.properties.entries()) {\n      settings[key as StringKeys<PluginSettings>] = property.get() as unknown;\n    }\n\n    return settings;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -3,19 +3,20 @@
  * This module defines a base class for creating plugin setting tabs in Obsidian.
  * It provides a utility method to bind value components to plugin settings and handle changes.
  */
-import type { ConditionalKeys, Promisable, WritableDeep } from 'type-fest';
+import type { ConditionalKeys, Promisable } from 'type-fest';
 import { PluginSettingTab } from 'obsidian';
 import type { StringKeys } from '../../Object.mjs';
 import type { ValueComponentWithChangeTracking } from '../Components/ValueComponentWithChangeTracking.mjs';
+import type { ValidationMessageHolder } from '../ValidationMessage.mjs';
 import type { PluginBase } from './PluginBase.mjs';
 /**
  * Options for binding a value component to a plugin setting.
  */
-export interface BindOptions {
+export interface BindOptions<T> {
     /**
      * A callback function that is called when the value of the component changes.
      */
-    onChanged?(): Promisable<void>;
+    onChanged?(newValue: T | undefined, oldValue: T): Promisable<void>;
     /**
      * If true, shows the validation message when the component value is invalid. Default is `true`.
      */
@@ -24,7 +25,7 @@ export interface BindOptions {
 /**
  * Extended options for binding a value component to a plugin setting.
  */
-export interface BindOptionsExtended<PluginSettings extends object, UIValue, Property extends StringKeys<PluginSettings>> extends BindOptions {
+export interface BindOptionsExtended<PluginSettings extends object, UIValue, Property extends StringKeys<PluginSettings>> extends BindOptions<PluginSettings[Property]> {
     /**
      * Converts the UI component's value back to the plugin settings value.
      * @param uiValue - The value of the UI component.
@@ -38,10 +39,7 @@ export interface BindOptionsExtended<PluginSettings extends object, UIValue, Pro
      */
     pluginSettingsToComponentValueConverter: (pluginSettingsValue: PluginSettings[Property]) => UIValue;
 }
-type ExtractPluginSettings<T extends PluginBase<any>> = WritableDeep<T['settings']>;
-interface ValidationMessageHolder {
-    validationMessage: string;
-}
+type ExtractPluginSettings<Plugin extends PluginBase<any>> = Plugin extends PluginBase<infer PluginSettings> ? PluginSettings : never;
 /**
  * Base class for creating plugin settings tabs in Obsidian.
  * Provides a method for binding value components to plugin settings and handling changes.
@@ -61,7 +59,7 @@ export declare abstract class PluginSettingsTabBase<TPlugin extends PluginBase<a
      * @param options - The options for binding the value component.
      * @returns The value component.
      */
-    bind<UIValue, TValueComponent>(valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>, property: ConditionalKeys<ExtractPluginSettings<TPlugin>, UIValue>, options?: BindOptions): TValueComponent;
+    bind<UIValue, TValueComponent>(valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>, property: ConditionalKeys<ExtractPluginSettings<TPlugin>, UIValue>, options?: BindOptions<UIValue>): TValueComponent;
     /**
      * Binds a value component to a plugin setting.
      *

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

@@ -10,6 +10,7 @@ import { invokeAsyncSafely } from "../../Async.mjs";
 import { CssClass } from "../../CssClass.mjs";
 import { noop } from "../../Function.mjs";
 import { getValidatorComponent } from "../Components/ValidatorComponent.mjs";
+import { isValidationMessageHolder } from "../ValidationMessage.mjs";
 import { getPluginId } from "./PluginId.mjs";
 class PluginSettingsTabBase extends PluginSettingTab {
   constructor(plugin) {
@@ -40,14 +41,11 @@ class PluginSettingsTabBase extends PluginSettingTab {
     const validatorElement = getValidatorComponent(valueComponent)?.validatorEl;
     const propertyObj = this.plugin.settingsManager.getProperty(property);
     valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(propertyObj.get())).onChange(async (uiValue) => {
+      const oldValue = propertyObj.get();
       const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);
-      if (isValidationMessageHolder(convertedValue)) {
-        propertyObj.validationMessage = convertedValue.validationMessage;
-        await propertyObj.set(void 0);
-      } else {
-        await propertyObj.set(convertedValue);
-      }
-      await optionsExt.onChanged();
+      await propertyObj.setAndValidate(convertedValue);
+      const newValue = isValidationMessageHolder(convertedValue) ? void 0 : convertedValue;
+      await optionsExt.onChanged(newValue, oldValue);
     });
     validatorElement?.addEventListener("focus", validate);
     validatorElement?.addEventListener("blur", validate);
@@ -60,7 +58,7 @@ class PluginSettingsTabBase extends PluginSettingTab {
       if (!propertyObj.validationMessage) {
         validatorElement.setCustomValidity("");
         validatorElement.checkValidity();
-        propertyObj.validationMessage = validatorElement.validationMessage;
+        propertyObj.set(validatorElement);
       }
       validatorElement.setCustomValidity(propertyObj.validationMessage);
       validatorElement.title = propertyObj.validationMessage;
@@ -74,10 +72,7 @@ class PluginSettingsTabBase extends PluginSettingTab {
     invokeAsyncSafely(() => this.plugin.settingsManager.saveToFile());
   }
 }
-function isValidationMessageHolder(value) {
-  return !!value.validationMessage;
-}
 export {
   PluginSettingsTabBase
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsTabBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation PluginSettingsTabBase\n * This module defines a base class for creating plugin setting tabs in Obsidian.\n * It provides a utility method to bind value components to plugin settings and handle changes.\n */\n\nimport type {\n  ConditionalKeys,\n  Promisable,\n  WritableDeep\n} from 'type-fest';\n\nimport { PluginSettingTab } from 'obsidian';\n\nimport type { StringKeys } from '../../Object.ts';\nimport type { ValueComponentWithChangeTracking } from '../Components/ValueComponentWithChangeTracking.ts';\nimport type { PluginBase } from './PluginBase.ts';\n\nimport { invokeAsyncSafely } from '../../Async.ts';\nimport { CssClass } from '../../CssClass.ts';\nimport { noop } from '../../Function.ts';\nimport { getValidatorComponent } from '../Components/ValidatorComponent.ts';\nimport { getPluginId } from './PluginId.ts';\n\n/**\n * Options for binding a value component to a plugin setting.\n */\nexport interface BindOptions {\n  /**\n   * A callback function that is called when the value of the component changes.\n   */\n  onChanged?(): Promisable<void>;\n\n  /**\n   * If true, shows the validation message when the component value is invalid. Default is `true`.\n   */\n  shouldShowValidationMessage?: boolean;\n}\n\n/**\n * Extended options for binding a value component to a plugin setting.\n */\nexport interface BindOptionsExtended<PluginSettings extends object, UIValue, Property extends StringKeys<PluginSettings>> extends BindOptions {\n  /**\n   * Converts the UI component's value back to the plugin settings value.\n   * @param uiValue - The value of the UI component.\n   * @returns The value to set on the plugin settings.\n   */\n  componentToPluginSettingsValueConverter: (uiValue: UIValue) => PluginSettings[Property] | ValidationMessageHolder;\n\n  /**\n   * Converts the plugin settings value to the value used by the UI component.\n   * @param pluginSettingsValue - The value of the property in the plugin settings.\n   * @returns The value to set on the UI component.\n   */\n  pluginSettingsToComponentValueConverter: (pluginSettingsValue: PluginSettings[Property]) => UIValue;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ExtractPluginSettings<T extends PluginBase<any>> = WritableDeep<T['settings']>;\n\ninterface ValidationMessageHolder {\n  validationMessage: string;\n}\n\n/**\n * Base class for creating plugin settings tabs in Obsidian.\n * Provides a method for binding value components to plugin settings and handling changes.\n *\n * @typeParam TPlugin - The type of the plugin that extends PluginBase.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport abstract class PluginSettingsTabBase<TPlugin extends PluginBase<any>> extends PluginSettingTab {\n  public constructor(public override plugin: TPlugin) {\n    super(plugin.app, plugin);\n    this.containerEl.addClass(CssClass.LibraryName, getPluginId(), CssClass.PluginSettingsTab);\n  }\n\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @param valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: ConditionalKeys<ExtractPluginSettings<TPlugin>, UIValue>,\n    options?: BindOptions\n  ): TValueComponent;\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @typeParam Property - The property of the plugin settings to bind to.\n   * @param valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    Property extends StringKeys<ExtractPluginSettings<TPlugin>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: Property,\n    options: BindOptionsExtended<ExtractPluginSettings<TPlugin>, UIValue, Property>\n  ): TValueComponent;\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @typeParam Property - The property of the plugin settings to bind to.\n   * @param valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    Property extends StringKeys<ExtractPluginSettings<TPlugin>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: Property,\n    options?: BindOptions\n  ): TValueComponent {\n    type PluginSettings = ExtractPluginSettings<TPlugin>;\n    type PropertyType = PluginSettings[Property];\n    const DEFAULT_OPTIONS: Required<BindOptionsExtended<PluginSettings, UIValue, Property>> = {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      componentToPluginSettingsValueConverter: (value: UIValue): PropertyType => value as PropertyType,\n      onChanged: noop,\n      pluginSettingsToComponentValueConverter: (value: PropertyType): UIValue => value as UIValue,\n      shouldShowValidationMessage: true\n    };\n\n    const optionsExt: Required<BindOptionsExtended<PluginSettings, UIValue, Property>> = { ...DEFAULT_OPTIONS, ...options };\n\n    const validatorElement = getValidatorComponent(valueComponent)?.validatorEl;\n\n    const propertyObj = this.plugin.settingsManager.getProperty(property);\n\n    valueComponent\n      .setValue(optionsExt.pluginSettingsToComponentValueConverter(propertyObj.get() as PropertyType))\n      .onChange(async (uiValue) => {\n        const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);\n        if (isValidationMessageHolder(convertedValue)) {\n          propertyObj.validationMessage = convertedValue.validationMessage;\n          await propertyObj.set(undefined);\n        } else {\n          await propertyObj.set(convertedValue);\n        }\n        await optionsExt.onChanged();\n      });\n\n    validatorElement?.addEventListener('focus', validate);\n    validatorElement?.addEventListener('blur', validate);\n\n    validate();\n    return valueComponent;\n\n    function validate(): void {\n      if (!validatorElement) {\n        return;\n      }\n\n      if (!propertyObj.validationMessage) {\n        validatorElement.setCustomValidity('');\n        validatorElement.checkValidity();\n        propertyObj.validationMessage = validatorElement.validationMessage;\n      }\n\n      validatorElement.setCustomValidity(propertyObj.validationMessage);\n      validatorElement.title = propertyObj.validationMessage;\n      if (validatorElement.isActiveElement() && optionsExt.shouldShowValidationMessage) {\n        validatorElement.reportValidity();\n      }\n    }\n  }\n\n  public override hide(): void {\n    super.hide();\n    invokeAsyncSafely(() => this.plugin.settingsManager.saveToFile());\n  }\n}\n\nfunction isValidationMessageHolder(value: unknown): value is ValidationMessageHolder {\n  return !!(value as Partial<ValidationMessageHolder>).validationMessage;\n}\n"],
  "mappings": ";;;;;;;AAYA,SAAS,wBAAwB;AAMjC,SAAS,yBAAyB;AAClC,SAAS,gBAAgB;AACzB,SAAS,YAAY;AACrB,SAAS,6BAA6B;AACtC,SAAS,mBAAmB;AAkDrB,MAAe,8BAA+D,iBAAiB;AAAA,EAC7F,YAA4B,QAAiB;AAClD,UAAM,OAAO,KAAK,MAAM;AADS;AAEjC,SAAK,YAAY,SAAS,SAAS,aAAa,YAAY,GAAG,SAAS,iBAAiB;AAAA,EAC3F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmDO,KAKL,gBACA,UACA,SACiB;AAGjB,UAAM,kBAAoF;AAAA;AAAA,MAExF,yCAAyC,CAAC,UAAiC;AAAA,MAC3E,WAAW;AAAA,MACX,yCAAyC,CAAC,UAAiC;AAAA,MAC3E,6BAA6B;AAAA,IAC/B;AAEA,UAAM,aAA+E,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAEtH,UAAM,mBAAmB,sBAAsB,cAAc,GAAG;AAEhE,UAAM,cAAc,KAAK,OAAO,gBAAgB,YAAY,QAAQ;AAEpE,mBACG,SAAS,WAAW,wCAAwC,YAAY,IAAI,CAAiB,CAAC,EAC9F,SAAS,OAAO,YAAY;AAC3B,YAAM,iBAAiB,WAAW,wCAAwC,OAAO;AACjF,UAAI,0BAA0B,cAAc,GAAG;AAC7C,oBAAY,oBAAoB,eAAe;AAC/C,cAAM,YAAY,IAAI,MAAS;AAAA,MACjC,OAAO;AACL,cAAM,YAAY,IAAI,cAAc;AAAA,MACtC;AACA,YAAM,WAAW,UAAU;AAAA,IAC7B,CAAC;AAEH,sBAAkB,iBAAiB,SAAS,QAAQ;AACpD,sBAAkB,iBAAiB,QAAQ,QAAQ;AAEnD,aAAS;AACT,WAAO;AAEP,aAAS,WAAiB;AACxB,UAAI,CAAC,kBAAkB;AACrB;AAAA,MACF;AAEA,UAAI,CAAC,YAAY,mBAAmB;AAClC,yBAAiB,kBAAkB,EAAE;AACrC,yBAAiB,cAAc;AAC/B,oBAAY,oBAAoB,iBAAiB;AAAA,MACnD;AAEA,uBAAiB,kBAAkB,YAAY,iBAAiB;AAChE,uBAAiB,QAAQ,YAAY;AACrC,UAAI,iBAAiB,gBAAgB,KAAK,WAAW,6BAA6B;AAChF,yBAAiB,eAAe;AAAA,MAClC;AAAA,IACF;AAAA,EACF;AAAA,EAEgB,OAAa;AAC3B,UAAM,KAAK;AACX,sBAAkB,MAAM,KAAK,OAAO,gBAAgB,WAAW,CAAC;AAAA,EAClE;AACF;AAEA,SAAS,0BAA0B,OAAkD;AACnF,SAAO,CAAC,CAAE,MAA2C;AACvD;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsTabBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation PluginSettingsTabBase\n * This module defines a base class for creating plugin setting tabs in Obsidian.\n * It provides a utility method to bind value components to plugin settings and handle changes.\n */\n\nimport type {\n  ConditionalKeys,\n  Promisable\n} from 'type-fest';\n\nimport { PluginSettingTab } from 'obsidian';\n\nimport type { StringKeys } from '../../Object.ts';\nimport type { ValueComponentWithChangeTracking } from '../Components/ValueComponentWithChangeTracking.ts';\nimport type { ValidationMessageHolder } from '../ValidationMessage.ts';\nimport type { PluginBase } from './PluginBase.ts';\n\nimport { invokeAsyncSafely } from '../../Async.ts';\nimport { CssClass } from '../../CssClass.ts';\nimport { noop } from '../../Function.ts';\nimport { getValidatorComponent } from '../Components/ValidatorComponent.ts';\nimport { isValidationMessageHolder } from '../ValidationMessage.ts';\nimport { getPluginId } from './PluginId.ts';\n\n/**\n * Options for binding a value component to a plugin setting.\n */\nexport interface BindOptions<T> {\n  /**\n   * A callback function that is called when the value of the component changes.\n   */\n  onChanged?(newValue: T | undefined, oldValue: T): Promisable<void>;\n\n  /**\n   * If true, shows the validation message when the component value is invalid. Default is `true`.\n   */\n  shouldShowValidationMessage?: boolean;\n}\n\n/**\n * Extended options for binding a value component to a plugin setting.\n */\nexport interface BindOptionsExtended<\n  PluginSettings extends object,\n  UIValue,\n  Property extends StringKeys<PluginSettings>\n> extends BindOptions<PluginSettings[Property]> {\n  /**\n   * Converts the UI component's value back to the plugin settings value.\n   * @param uiValue - The value of the UI component.\n   * @returns The value to set on the plugin settings.\n   */\n  componentToPluginSettingsValueConverter: (uiValue: UIValue) => PluginSettings[Property] | ValidationMessageHolder;\n\n  /**\n   * Converts the plugin settings value to the value used by the UI component.\n   * @param pluginSettingsValue - The value of the property in the plugin settings.\n   * @returns The value to set on the UI component.\n   */\n  pluginSettingsToComponentValueConverter: (pluginSettingsValue: PluginSettings[Property]) => UIValue;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ExtractPluginSettings<Plugin extends PluginBase<any>> = Plugin extends PluginBase<infer PluginSettings> ? PluginSettings : never;\n\n/**\n * Base class for creating plugin settings tabs in Obsidian.\n * Provides a method for binding value components to plugin settings and handling changes.\n *\n * @typeParam TPlugin - The type of the plugin that extends PluginBase.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport abstract class PluginSettingsTabBase<TPlugin extends PluginBase<any>> extends PluginSettingTab {\n  public constructor(public override plugin: TPlugin) {\n    super(plugin.app, plugin);\n    this.containerEl.addClass(CssClass.LibraryName, getPluginId(), CssClass.PluginSettingsTab);\n  }\n\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @param valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: ConditionalKeys<ExtractPluginSettings<TPlugin>, UIValue>,\n    options?: BindOptions<UIValue>\n  ): TValueComponent;\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @typeParam Property - The property of the plugin settings to bind to.\n   * @param valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    Property extends StringKeys<ExtractPluginSettings<TPlugin>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: Property,\n    options: BindOptionsExtended<ExtractPluginSettings<TPlugin>, UIValue, Property>\n  ): TValueComponent;\n  /**\n   * Binds a value component to a plugin setting.\n   *\n   * @typeParam UIValue - The type of the value of the UI component.\n   * @typeParam TValueComponent - The type of the value component.\n   * @typeParam Property - The property of the plugin settings to bind to.\n   * @param valueComponent - The value component to bind.\n   * @param property - The property of the plugin settings to bind to.\n   * @param options - The options for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    Property extends StringKeys<ExtractPluginSettings<TPlugin>>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    property: Property,\n    options?: BindOptions<ExtractPluginSettings<TPlugin>[Property]>\n  ): TValueComponent {\n    type PluginSettings = ExtractPluginSettings<TPlugin>;\n    type PropertyType = PluginSettings[Property];\n    const DEFAULT_OPTIONS: Required<BindOptionsExtended<PluginSettings, UIValue, Property>> = {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      componentToPluginSettingsValueConverter: (value: UIValue): PropertyType => value as PropertyType,\n      onChanged: noop,\n      pluginSettingsToComponentValueConverter: (value: PropertyType): UIValue => value as UIValue,\n      shouldShowValidationMessage: true\n    };\n\n    const optionsExt: Required<BindOptionsExtended<PluginSettings, UIValue, Property>> = { ...DEFAULT_OPTIONS, ...options };\n\n    const validatorElement = getValidatorComponent(valueComponent)?.validatorEl;\n\n    const propertyObj = this.plugin.settingsManager.getProperty(property);\n\n    valueComponent\n      .setValue(optionsExt.pluginSettingsToComponentValueConverter(propertyObj.get() as PropertyType))\n      .onChange(async (uiValue) => {\n        const oldValue = propertyObj.get() as PropertyType;\n        const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);\n        await propertyObj.setAndValidate(convertedValue);\n        const newValue = isValidationMessageHolder(convertedValue) ? undefined : convertedValue;\n        await optionsExt.onChanged(newValue, oldValue);\n      });\n\n    validatorElement?.addEventListener('focus', validate);\n    validatorElement?.addEventListener('blur', validate);\n\n    validate();\n    return valueComponent;\n\n    function validate(): void {\n      if (!validatorElement) {\n        return;\n      }\n\n      if (!propertyObj.validationMessage) {\n        validatorElement.setCustomValidity('');\n        validatorElement.checkValidity();\n        propertyObj.set(validatorElement);\n      }\n\n      validatorElement.setCustomValidity(propertyObj.validationMessage);\n      validatorElement.title = propertyObj.validationMessage;\n      if (validatorElement.isActiveElement() && optionsExt.shouldShowValidationMessage) {\n        validatorElement.reportValidity();\n      }\n    }\n  }\n\n  public override hide(): void {\n    super.hide();\n    invokeAsyncSafely(() => this.plugin.settingsManager.saveToFile());\n  }\n}\n"],
  "mappings": ";;;;;;;AAWA,SAAS,wBAAwB;AAOjC,SAAS,yBAAyB;AAClC,SAAS,gBAAgB;AACzB,SAAS,YAAY;AACrB,SAAS,6BAA6B;AACtC,SAAS,iCAAiC;AAC1C,SAAS,mBAAmB;AAkDrB,MAAe,8BAA+D,iBAAiB;AAAA,EAC7F,YAA4B,QAAiB;AAClD,UAAM,OAAO,KAAK,MAAM;AADS;AAEjC,SAAK,YAAY,SAAS,SAAS,aAAa,YAAY,GAAG,SAAS,iBAAiB;AAAA,EAC3F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmDO,KAKL,gBACA,UACA,SACiB;AAGjB,UAAM,kBAAoF;AAAA;AAAA,MAExF,yCAAyC,CAAC,UAAiC;AAAA,MAC3E,WAAW;AAAA,MACX,yCAAyC,CAAC,UAAiC;AAAA,MAC3E,6BAA6B;AAAA,IAC/B;AAEA,UAAM,aAA+E,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAEtH,UAAM,mBAAmB,sBAAsB,cAAc,GAAG;AAEhE,UAAM,cAAc,KAAK,OAAO,gBAAgB,YAAY,QAAQ;AAEpE,mBACG,SAAS,WAAW,wCAAwC,YAAY,IAAI,CAAiB,CAAC,EAC9F,SAAS,OAAO,YAAY;AAC3B,YAAM,WAAW,YAAY,IAAI;AACjC,YAAM,iBAAiB,WAAW,wCAAwC,OAAO;AACjF,YAAM,YAAY,eAAe,cAAc;AAC/C,YAAM,WAAW,0BAA0B,cAAc,IAAI,SAAY;AACzE,YAAM,WAAW,UAAU,UAAU,QAAQ;AAAA,IAC/C,CAAC;AAEH,sBAAkB,iBAAiB,SAAS,QAAQ;AACpD,sBAAkB,iBAAiB,QAAQ,QAAQ;AAEnD,aAAS;AACT,WAAO;AAEP,aAAS,WAAiB;AACxB,UAAI,CAAC,kBAAkB;AACrB;AAAA,MACF;AAEA,UAAI,CAAC,YAAY,mBAAmB;AAClC,yBAAiB,kBAAkB,EAAE;AACrC,yBAAiB,cAAc;AAC/B,oBAAY,IAAI,gBAAgB;AAAA,MAClC;AAEA,uBAAiB,kBAAkB,YAAY,iBAAiB;AAChE,uBAAiB,QAAQ,YAAY;AACrC,UAAI,iBAAiB,gBAAgB,KAAK,WAAW,6BAA6B;AAChF,yBAAiB,eAAe;AAAA,MAClC;AAAA,IACF;AAAA,EACF;AAAA,EAEgB,OAAa;AAC3B,UAAM,KAAK;AACX,sBAAkB,MAAM,KAAK,OAAO,gBAAgB,WAAW,CAAC;AAAA,EAClE;AACF;",
  "names": []
}


package/dist/lib/esm/obsidian/ValidationMessage.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Holds a validation message.
+ */
+export interface ValidationMessageHolder {
+    /**
+     * The validation message.
+     */
+    validationMessage: string;
+}
+/**
+ * Type guard to check if a value is a validation message holder.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a validation message holder, `false` otherwise.
+ */
+export declare function isValidationMessageHolder(value: unknown): value is ValidationMessageHolder;

package/dist/lib/esm/obsidian/ValidationMessage.mjs

@@ -0,0 +1,14 @@
+/*
+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:__name(()=>"/","cwd"),env:{},platform:"android"};globalThis.process=browserProcess})();
+
+function isValidationMessageHolder(value) {
+  return !!value.validationMessage;
+}
+export {
+  isValidationMessageHolder
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL1ZhbGlkYXRpb25NZXNzYWdlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEhvbGRzIGEgdmFsaWRhdGlvbiBtZXNzYWdlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFZhbGlkYXRpb25NZXNzYWdlSG9sZGVyIHtcbiAgLyoqXG4gICAqIFRoZSB2YWxpZGF0aW9uIG1lc3NhZ2UuXG4gICAqL1xuICB2YWxpZGF0aW9uTWVzc2FnZTogc3RyaW5nO1xufVxuXG4vKipcbiAqIFR5cGUgZ3VhcmQgdG8gY2hlY2sgaWYgYSB2YWx1ZSBpcyBhIHZhbGlkYXRpb24gbWVzc2FnZSBob2xkZXIuXG4gKlxuICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGNoZWNrLlxuICogQHJldHVybnMgYHRydWVgIGlmIHRoZSB2YWx1ZSBpcyBhIHZhbGlkYXRpb24gbWVzc2FnZSBob2xkZXIsIGBmYWxzZWAgb3RoZXJ3aXNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNWYWxpZGF0aW9uTWVzc2FnZUhvbGRlcih2YWx1ZTogdW5rbm93bik6IHZhbHVlIGlzIFZhbGlkYXRpb25NZXNzYWdlSG9sZGVyIHtcbiAgcmV0dXJuICEhKHZhbHVlIGFzIFBhcnRpYWw8VmFsaWRhdGlvbk1lc3NhZ2VIb2xkZXI+KS52YWxpZGF0aW9uTWVzc2FnZTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7QUFnQk8sU0FBUywwQkFBMEIsT0FBa0Q7QUFDMUYsU0FBTyxDQUFDLENBQUUsTUFBMkM7QUFDdkQ7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/obsidian/index.d.mts

@@ -27,5 +27,6 @@ export * as Reference from './Reference.mjs';
 export * as RenameDeleteHandler from './RenameDeleteHandler.mjs';
 export * as ResourceUrl from './ResourceUrl.mjs';
 export * as SettingEx from './SettingEx.mjs';
+export * as ValidationMessage from './ValidationMessage.mjs';
 export * as Vault from './Vault.mjs';
 export * as VaultEx from './VaultEx.mjs';

package/dist/lib/esm/obsidian/index.mjs

@@ -34,6 +34,7 @@ import * as Reference from "./Reference.mjs";
 import * as RenameDeleteHandler from "./RenameDeleteHandler.mjs";
 import * as ResourceUrl from "./ResourceUrl.mjs";
 import * as SettingEx from "./SettingEx.mjs";
+import * as ValidationMessage from "./ValidationMessage.mjs";
 import * as Vault from "./Vault.mjs";
 import * as VaultEx from "./VaultEx.mjs";
 export {
@@ -66,7 +67,8 @@ export {
   RenameDeleteHandler,
   ResourceUrl,
   SettingEx,
+  ValidationMessage,
   Vault,
   VaultEx
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/obsidian/ValidationMessage/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/obsidian/ValidationMessage.cjs",
+  "module": "../../dist/lib/esm/obsidian/ValidationMessage.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/obsidian/ValidationMessage.d.cts"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "22.1.1-beta.3",
+  "version": "22.1.1-beta.5",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development",
   "keywords": [
     "obsidian"