obsidian-dev-utils 2.20.0 → 2.21.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 2.21.0
+
+- Handle default setting
+
 ## 2.20.0
 
 - Pass plugin instead of tab

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

@@ -34,14 +34,18 @@ var __process = globalThis["process"] ?? {
   "platform": "android"
 };
 function bindUiComponent(plugin, uiComponent, property, options) {
-  options ??= {
+  const DEFAULT_OPTIONS = {
+    autoSave: true,
     settingToUIValueConverter: (value) => value,
     uiToSettingValueConverter: (value) => value
   };
-  const pluginSettings = options.pluginSettings ?? plugin.settingsCopy;
-  uiComponent.setValue(options.settingToUIValueConverter(pluginSettings[property])).onChange(async (uiValue) => {
-    if (options.uiValueValidator) {
-      const errorMessage = options.uiValueValidator(uiValue);
+  const optionsExt = Object.assign(options, DEFAULT_OPTIONS);
+  const pluginExt = plugin;
+  const uiComponentExt = uiComponent;
+  const pluginSettings = optionsExt.pluginSettings ?? pluginExt.settingsCopy;
+  uiComponentExt.setValue(optionsExt.settingToUIValueConverter(pluginSettings[property])).onChange(async (uiValue) => {
+    if (optionsExt.uiValueValidator) {
+      const errorMessage = optionsExt.uiValueValidator(uiValue);
       const validatorElement = getValidatorElement(uiComponent);
       if (validatorElement) {
         validatorElement.setCustomValidity(errorMessage ?? "");
@@ -51,9 +55,9 @@ function bindUiComponent(plugin, uiComponent, property, options) {
         return;
       }
     }
-    pluginSettings[property] = options.uiToSettingValueConverter(uiValue);
-    if (options.autoSave ?? true) {
-      await plugin.saveSettings(pluginSettings);
+    pluginSettings[property] = optionsExt.uiToSettingValueConverter(uiValue);
+    if (optionsExt.autoSave) {
+      await pluginExt.saveSettings(pluginSettings);
     }
   });
   return uiComponent;
@@ -77,4 +81,4 @@ function getValidatorElement(uiComponent) {
 0 && (module.exports = {
   bindUiComponent
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/Plugin/UIComponent.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis[\"import.meta.url\"] ?? (()=>require(\"node:url\").pathToFileURL(__filename))();\nvar __process = globalThis[\"process\"] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport type { KeysMatching } from \"../../@types.ts\";\nimport type { PluginBase } from \"./PluginBase.ts\";\nimport {\n  DropdownComponent,\n  SliderComponent,\n  TextAreaComponent,\n  TextComponent\n} from \"obsidian\";\n\n/**\n * A UI component that can be bound to a plugin setting.\n */\nexport interface UIComponent<UIValue> {\n  /**\n   * Sets the value of the component.\n   * @param value - The value to set on the component.\n   */\n  setValue(value: UIValue): this;\n\n  /**\n   * Sets a callback function to be called when the value of the component changes.\n   * @param callback - A callback function that is called when the value of the component changes.\n   */\n  onChange(callback: (newValue: UIValue) => Promise<void>): this;\n}\n\n/**\n * A UI component that can be validated.\n */\ninterface ValidatorElement {\n  /**\n   * Sets a custom error message on the element.\n   * @param error - The error message to set on the element.\n   */\n  setCustomValidity(error: string): void;\n\n  /**\n   * Reports the validity of the element.\n   */\n  reportValidity(): boolean;\n}\n\n/**\n * Options for binding a value component to a plugin setting.\n */\ntype BindUIComponentOptions<PluginSettings, Property extends keyof PluginSettings, UIValueType> = {\n  // If true, saves the plugin settings automatically after the component value changes. Default is `true`.\n  autoSave?: boolean;\n\n  /**\n   * The plugin settings object to bind the component to. Default is the plugin's current settings.\n   */\n  pluginSettings?: PluginSettings;\n\n  /**\n   * Converts the setting value to the value used by the UI component.\n   * @param propertyValue - The value of the property in the plugin settings.\n   * @returns The value to set on the UI component.\n   */\n  settingToUIValueConverter: (propertyValue: PluginSettings[Property]) => UIValueType;\n\n  /**\n   * Converts the UI component's value back to the setting value.\n   * @param uiValue - The value of the UI component.\n   * @returns The value to set on the plugin settings.\n   */\n  uiToSettingValueConverter: (uiValue: UIValueType) => PluginSettings[Property];\n\n  /**\n   * Validates the UI value before setting it on the plugin settings.\n   * @param uiValue - The value of the UI component.\n   * @returns An error message if the value is invalid, or `null` if it is valid.\n   */\n  uiValueValidator?: (uiValue: UIValueType) => string | null;\n};\n\n/**\n * Binds a value component to a property in the plugin settings with optional automatic saving and value conversion.\n *\n * @typeParam Plugin - The type of the plugin that extends `PluginBase`.\n * @typeParam TUIComponent - The type of the value component extending `UIComponent`.\n * @typeParam Property - The key of the plugin setting that the component is bound to.\n * @typeParam UIValueType - The inferred type based on the UI component's type.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param plugin - The plugin.\n * @param uiComponent - The component that will display and interact with the setting value.\n * @param property - The property key in `PluginSettings` to bind to the UI component.\n * @param options - Configuration options.\n *\n * @returns The `UIComponent` instance that was bound to the property.\n */\nexport function bindUiComponent<\n  Plugin extends PluginBase<object>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends KeysMatching<PluginSettings, UIValueType>,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never,\n>(\n  plugin: Plugin,\n  uiComponent: TUIComponent,\n  property: Property,\n  options?: BindUIComponentOptions<PluginSettings, Property, UIValueType>\n): TUIComponent;\n\n/**\n * Binds a value component to a property in the plugin settings with optional automatic saving and value conversion.\n *\n * @typeParam Plugin - The type of the plugin that extends `PluginBase`.\n * @typeParam TUIComponent - The type of the value component extending `UIComponent`.\n * @typeParam Property - The key of the plugin setting that the component is bound to.\n * @typeParam UIValueType - The inferred type based on the UI component's type.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param plugin - The plugin.\n * @param uiComponent - The component that will display and interact with the setting value.\n * @param property - The property key in `PluginSettings` to bind to the UI component.\n * @param options - Configuration options.\n *\n * @returns The `UIComponent` instance that was bound to the property.\n */\nexport function bindUiComponent<\n  Plugin extends PluginBase<object>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends keyof PluginSettings,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never,\n>(\n  plugin: Plugin,\n  uiComponent: TUIComponent,\n  property: Property,\n  options: BindUIComponentOptions<PluginSettings, Property, UIValueType>\n): TUIComponent;\n\n/**\n * Binds a value component to a property in the plugin settings with optional automatic saving and value conversion.\n *\n * @typeParam Plugin - The type of the plugin that extends `PluginBase`.\n * @typeParam TUIComponent - The type of the value component extending `UIComponent`.\n * @typeParam Property - The key of the plugin setting that the component is bound to.\n * @typeParam UIValueType - The inferred type based on the UI component's type.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param plugin - The plugin.\n * @param uiComponent - The component that will display and interact with the setting value.\n * @param property - The property key in `PluginSettings` to bind to the UI component.\n * @param options - Configuration options.\n *\n * @returns The `UIComponent` instance that was bound to the property.\n */\nexport function bindUiComponent<\n  Plugin extends PluginBase<object>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends keyof PluginSettings,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never,\n>(\n  plugin: Plugin,\n  uiComponent: TUIComponent,\n  property: Property,\n  options?: BindUIComponentOptions<PluginSettings, Property, UIValueType>\n): TUIComponent {\n  options ??= {\n    settingToUIValueConverter: (value): UIValueType => value as UIValueType,\n    uiToSettingValueConverter: (value): PluginSettings[Property] => value as PluginSettings[Property],\n  };\n  const pluginSettings = options.pluginSettings ?? plugin.settingsCopy as PluginSettings;\n  (uiComponent as UIComponent<UIValueType>)\n    .setValue(options.settingToUIValueConverter(pluginSettings[property]))\n    .onChange(async (uiValue) => {\n      if (options.uiValueValidator) {\n        const errorMessage = options.uiValueValidator(uiValue);\n        const validatorElement = getValidatorElement(uiComponent);\n        if (validatorElement) {\n          validatorElement.setCustomValidity(errorMessage ?? \"\");\n          validatorElement.reportValidity();\n        }\n        if (errorMessage) {\n          return;\n        }\n      }\n      pluginSettings[property] = options.uiToSettingValueConverter(uiValue);\n      if (options.autoSave ?? true) {\n        await plugin.saveSettings(pluginSettings);\n      }\n    });\n  return uiComponent;\n}\n\n/**\n * Gets the validator element from a UI component if it exists.\n * @param uiComponent - The UI component to get the validator element from.\n * @returns The validator element if it exists, or `null` if it does not.\n */\nfunction getValidatorElement(uiComponent: UIComponent<unknown>): ValidatorElement | null {\n  if (uiComponent instanceof DropdownComponent) {\n    return uiComponent.selectEl;\n  }\n\n  if (uiComponent instanceof SliderComponent) {\n    return uiComponent.sliderEl;\n  }\n\n  if (uiComponent instanceof TextAreaComponent) {\n    return uiComponent.inputEl;\n  }\n\n  if (uiComponent instanceof TextComponent) {\n    return uiComponent.inputEl;\n  }\n\n  return null;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,sBAKO;AAbP,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAI,QAAQ,UAAU,EAAE,cAAc,UAAU,GAAG;AAC7G,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAuJO,SAAS,gBAOd,QACA,aACA,UACA,SACc;AACd,cAAY;AAAA,IACV,2BAA2B,CAAC,UAAuB;AAAA,IACnD,2BAA2B,CAAC,UAAoC;AAAA,EAClE;AACA,QAAM,iBAAiB,QAAQ,kBAAkB,OAAO;AACxD,EAAC,YACE,SAAS,QAAQ,0BAA0B,eAAe,QAAQ,CAAC,CAAC,EACpE,SAAS,OAAO,YAAY;AAC3B,QAAI,QAAQ,kBAAkB;AAC5B,YAAM,eAAe,QAAQ,iBAAiB,OAAO;AACrD,YAAM,mBAAmB,oBAAoB,WAAW;AACxD,UAAI,kBAAkB;AACpB,yBAAiB,kBAAkB,gBAAgB,EAAE;AACrD,yBAAiB,eAAe;AAAA,MAClC;AACA,UAAI,cAAc;AAChB;AAAA,MACF;AAAA,IACF;AACA,mBAAe,QAAQ,IAAI,QAAQ,0BAA0B,OAAO;AACpE,QAAI,QAAQ,YAAY,MAAM;AAC5B,YAAM,OAAO,aAAa,cAAc;AAAA,IAC1C;AAAA,EACF,CAAC;AACH,SAAO;AACT;AAOA,SAAS,oBAAoB,aAA4D;AACvF,MAAI,uBAAuB,mCAAmB;AAC5C,WAAO,YAAY;AAAA,EACrB;AAEA,MAAI,uBAAuB,iCAAiB;AAC1C,WAAO,YAAY;AAAA,EACrB;AAEA,MAAI,uBAAuB,mCAAmB;AAC5C,WAAO,YAAY;AAAA,EACrB;AAEA,MAAI,uBAAuB,+BAAe;AACxC,WAAO,YAAY;AAAA,EACrB;AAEA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/Plugin/UIComponent.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis[\"import.meta.url\"] ?? (()=>require(\"node:url\").pathToFileURL(__filename))();\nvar __process = globalThis[\"process\"] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport type { KeysMatching } from \"../../@types.ts\";\nimport type { PluginBase } from \"./PluginBase.ts\";\nimport {\n  DropdownComponent,\n  SliderComponent,\n  TextAreaComponent,\n  TextComponent\n} from \"obsidian\";\n\n/**\n * A UI component that can be bound to a plugin setting.\n */\nexport interface UIComponent<UIValue> {\n  /**\n   * Sets the value of the component.\n   * @param value - The value to set on the component.\n   */\n  setValue(value: UIValue): this;\n\n  /**\n   * Sets a callback function to be called when the value of the component changes.\n   * @param callback - A callback function that is called when the value of the component changes.\n   */\n  onChange(callback: (newValue: UIValue) => Promise<void>): this;\n}\n\n/**\n * A UI component that can be validated.\n */\ninterface ValidatorElement {\n  /**\n   * Sets a custom error message on the element.\n   * @param error - The error message to set on the element.\n   */\n  setCustomValidity(error: string): void;\n\n  /**\n   * Reports the validity of the element.\n   */\n  reportValidity(): boolean;\n}\n\n/**\n * Options for binding a value component to a plugin setting.\n */\ninterface BindUIComponentOptions<PluginSettings, UIValueType> {\n  // If true, saves the plugin settings automatically after the component value changes. Default is `true`.\n  autoSave?: boolean;\n\n  /**\n   * The plugin settings object to bind the component to. Default is the plugin's current settings.\n   */\n  pluginSettings?: PluginSettings;\n\n  /**\n   * Validates the UI value before setting it on the plugin settings.\n   * @param uiValue - The value of the UI component.\n   * @returns An error message if the value is invalid, or `null` if it is valid.\n   */\n  uiValueValidator?: (uiValue: UIValueType) => string | null;\n}\n\n/**\n * Extended options for binding a value component to a plugin setting.\n */\ninterface BindUIComponentOptionsExtended<PluginSettings, UIValueType, Property extends keyof PluginSettings> extends BindUIComponentOptions<PluginSettings, UIValueType> {\n  /**\n * Converts the setting value to the value used by the UI component.\n * @param propertyValue - The value of the property in the plugin settings.\n * @returns The value to set on the UI component.\n */\n  settingToUIValueConverter: (propertyValue: PluginSettings[Property]) => UIValueType;\n\n  /**\n   * Converts the UI component's value back to the setting value.\n   * @param uiValue - The value of the UI component.\n   * @returns The value to set on the plugin settings.\n   */\n  uiToSettingValueConverter: (uiValue: UIValueType) => PluginSettings[Property];\n}\n\n/**\n * Binds a value component to a property in the plugin settings with optional automatic saving and value conversion.\n *\n * @typeParam Plugin - The type of the plugin that extends `PluginBase`.\n * @typeParam TUIComponent - The type of the value component extending `UIComponent`.\n * @typeParam Property - The key of the plugin setting that the component is bound to.\n * @typeParam UIValueType - The inferred type based on the UI component's type.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param plugin - The plugin.\n * @param uiComponent - The component that will display and interact with the setting value.\n * @param property - The property key in `PluginSettings` to bind to the UI component.\n * @param options - Configuration options.\n *\n * @returns The `UIComponent` instance that was bound to the property.\n */\nexport function bindUiComponent<\n  Plugin extends PluginBase<object>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends KeysMatching<PluginSettings, UIValueType>,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never,\n>(\n  plugin: Plugin,\n  uiComponent: TUIComponent,\n  property: Property,\n  options?: BindUIComponentOptions<PluginSettings, UIValueType>\n): TUIComponent;\n\n/**\n * Binds a value component to a property in the plugin settings with optional automatic saving and value conversion.\n *\n * @typeParam Plugin - The type of the plugin that extends `PluginBase`.\n * @typeParam TUIComponent - The type of the value component extending `UIComponent`.\n * @typeParam Property - The key of the plugin setting that the component is bound to.\n * @typeParam UIValueType - The inferred type based on the UI component's type.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param plugin - The plugin.\n * @param uiComponent - The component that will display and interact with the setting value.\n * @param property - The property key in `PluginSettings` to bind to the UI component.\n * @param options - Configuration options.\n *\n * @returns The `UIComponent` instance that was bound to the property.\n */\nexport function bindUiComponent<\n  Plugin extends PluginBase<object>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends keyof PluginSettings,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never,\n>(\n  plugin: Plugin,\n  uiComponent: TUIComponent,\n  property: Property,\n  options: BindUIComponentOptionsExtended<PluginSettings, UIValueType, Property>\n): TUIComponent;\n\n/**\n * Binds a value component to a property in the plugin settings with optional automatic saving and value conversion.\n *\n * @typeParam Plugin - The type of the plugin that extends `PluginBase`.\n * @typeParam TUIComponent - The type of the value component extending `UIComponent`.\n * @typeParam Property - The key of the plugin setting that the component is bound to.\n * @typeParam UIValueType - The inferred type based on the UI component's type.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param plugin - The plugin.\n * @param uiComponent - The component that will display and interact with the setting value.\n * @param property - The property key in `PluginSettings` to bind to the UI component.\n * @param options - Configuration options.\n *\n * @returns The `UIComponent` instance that was bound to the property.\n */\nexport function bindUiComponent<\n  Plugin extends PluginBase<object>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends keyof PluginSettings,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never,\n>(\n  plugin: Plugin,\n  uiComponent: TUIComponent,\n  property: Property,\n  options?: BindUIComponentOptions<PluginSettings, UIValueType>\n): TUIComponent {\n  type PropertyType = PluginSettings[Property];\n  const DEFAULT_OPTIONS: BindUIComponentOptionsExtended<PluginSettings, UIValueType, Property> = {\n    autoSave: true,\n    settingToUIValueConverter: (value): UIValueType => value as UIValueType,\n    uiToSettingValueConverter: (value): PropertyType => value as PropertyType\n  };\n\n  const optionsExt = Object.assign(options as BindUIComponentOptionsExtended<PluginSettings, UIValueType, Property>, DEFAULT_OPTIONS);\n  const pluginExt = plugin as unknown as PluginBase<PluginSettings>;\n  const uiComponentExt = uiComponent as UIComponent<UIValueType>;\n  const pluginSettings = optionsExt.pluginSettings ?? pluginExt.settingsCopy;\n  uiComponentExt\n    .setValue(optionsExt.settingToUIValueConverter(pluginSettings[property]))\n    .onChange(async (uiValue) => {\n      if (optionsExt.uiValueValidator) {\n        const errorMessage = optionsExt.uiValueValidator(uiValue);\n        const validatorElement = getValidatorElement(uiComponent);\n        if (validatorElement) {\n          validatorElement.setCustomValidity(errorMessage ?? \"\");\n          validatorElement.reportValidity();\n        }\n        if (errorMessage) {\n          return;\n        }\n      }\n      pluginSettings[property] = optionsExt.uiToSettingValueConverter(uiValue);\n      if (optionsExt.autoSave) {\n        await pluginExt.saveSettings(pluginSettings);\n      }\n    });\n  return uiComponent;\n}\n\n/**\n * Gets the validator element from a UI component if it exists.\n * @param uiComponent - The UI component to get the validator element from.\n * @returns The validator element if it exists, or `null` if it does not.\n */\nfunction getValidatorElement(uiComponent: UIComponent<unknown>): ValidatorElement | null {\n  if (uiComponent instanceof DropdownComponent) {\n    return uiComponent.selectEl;\n  }\n\n  if (uiComponent instanceof SliderComponent) {\n    return uiComponent.sliderEl;\n  }\n\n  if (uiComponent instanceof TextAreaComponent) {\n    return uiComponent.inputEl;\n  }\n\n  if (uiComponent instanceof TextComponent) {\n    return uiComponent.inputEl;\n  }\n\n  return null;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,sBAKO;AAbP,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAI,QAAQ,UAAU,EAAE,cAAc,UAAU,GAAG;AAC7G,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AA4JO,SAAS,gBAOd,QACA,aACA,UACA,SACc;AAEd,QAAM,kBAAyF;AAAA,IAC7F,UAAU;AAAA,IACV,2BAA2B,CAAC,UAAuB;AAAA,IACnD,2BAA2B,CAAC,UAAwB;AAAA,EACtD;AAEA,QAAM,aAAa,OAAO,OAAO,SAAkF,eAAe;AAClI,QAAM,YAAY;AAClB,QAAM,iBAAiB;AACvB,QAAM,iBAAiB,WAAW,kBAAkB,UAAU;AAC9D,iBACG,SAAS,WAAW,0BAA0B,eAAe,QAAQ,CAAC,CAAC,EACvE,SAAS,OAAO,YAAY;AAC3B,QAAI,WAAW,kBAAkB;AAC/B,YAAM,eAAe,WAAW,iBAAiB,OAAO;AACxD,YAAM,mBAAmB,oBAAoB,WAAW;AACxD,UAAI,kBAAkB;AACpB,yBAAiB,kBAAkB,gBAAgB,EAAE;AACrD,yBAAiB,eAAe;AAAA,MAClC;AACA,UAAI,cAAc;AAChB;AAAA,MACF;AAAA,IACF;AACA,mBAAe,QAAQ,IAAI,WAAW,0BAA0B,OAAO;AACvE,QAAI,WAAW,UAAU;AACvB,YAAM,UAAU,aAAa,cAAc;AAAA,IAC7C;AAAA,EACF,CAAC;AACH,SAAO;AACT;AAOA,SAAS,oBAAoB,aAA4D;AACvF,MAAI,uBAAuB,mCAAmB;AAC5C,WAAO,YAAY;AAAA,EACrB;AAEA,MAAI,uBAAuB,iCAAiB;AAC1C,WAAO,YAAY;AAAA,EACrB;AAEA,MAAI,uBAAuB,mCAAmB;AAC5C,WAAO,YAAY;AAAA,EACrB;AAEA,MAAI,uBAAuB,+BAAe;AACxC,WAAO,YAAY;AAAA,EACrB;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/obsidian/Plugin/UIComponent.d.ts

@@ -18,17 +18,28 @@ export interface UIComponent<UIValue> {
 /**
  * Options for binding a value component to a plugin setting.
  */
-type BindUIComponentOptions<PluginSettings, Property extends keyof PluginSettings, UIValueType> = {
+interface BindUIComponentOptions<PluginSettings, UIValueType> {
     autoSave?: boolean;
     /**
      * The plugin settings object to bind the component to. Default is the plugin's current settings.
      */
     pluginSettings?: PluginSettings;
     /**
-     * Converts the setting value to the value used by the UI component.
-     * @param propertyValue - The value of the property in the plugin settings.
-     * @returns The value to set on the UI component.
+     * Validates the UI value before setting it on the plugin settings.
+     * @param uiValue - The value of the UI component.
+     * @returns An error message if the value is invalid, or `null` if it is valid.
      */
+    uiValueValidator?: (uiValue: UIValueType) => string | null;
+}
+/**
+ * Extended options for binding a value component to a plugin setting.
+ */
+interface BindUIComponentOptionsExtended<PluginSettings, UIValueType, Property extends keyof PluginSettings> extends BindUIComponentOptions<PluginSettings, UIValueType> {
+    /**
+   * Converts the setting value to the value used by the UI component.
+   * @param propertyValue - The value of the property in the plugin settings.
+   * @returns The value to set on the UI component.
+   */
     settingToUIValueConverter: (propertyValue: PluginSettings[Property]) => UIValueType;
     /**
      * Converts the UI component's value back to the setting value.
@@ -36,13 +47,7 @@ type BindUIComponentOptions<PluginSettings, Property extends keyof PluginSetting
      * @returns The value to set on the plugin settings.
      */
     uiToSettingValueConverter: (uiValue: UIValueType) => PluginSettings[Property];
-    /**
-     * Validates the UI value before setting it on the plugin settings.
-     * @param uiValue - The value of the UI component.
-     * @returns An error message if the value is invalid, or `null` if it is valid.
-     */
-    uiValueValidator?: (uiValue: UIValueType) => string | null;
-};
+}
 /**
  * Binds a value component to a property in the plugin settings with optional automatic saving and value conversion.
  *
@@ -59,7 +64,7 @@ type BindUIComponentOptions<PluginSettings, Property extends keyof PluginSetting
  *
  * @returns The `UIComponent` instance that was bound to the property.
  */
-export declare function bindUiComponent<Plugin extends PluginBase<object>, TUIComponent extends UIComponent<unknown>, Property extends KeysMatching<PluginSettings, UIValueType>, UIValueType = TUIComponent extends UIComponent<infer P> ? P : never, PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never>(plugin: Plugin, uiComponent: TUIComponent, property: Property, options?: BindUIComponentOptions<PluginSettings, Property, UIValueType>): TUIComponent;
+export declare function bindUiComponent<Plugin extends PluginBase<object>, TUIComponent extends UIComponent<unknown>, Property extends KeysMatching<PluginSettings, UIValueType>, UIValueType = TUIComponent extends UIComponent<infer P> ? P : never, PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never>(plugin: Plugin, uiComponent: TUIComponent, property: Property, options?: BindUIComponentOptions<PluginSettings, UIValueType>): TUIComponent;
 /**
  * Binds a value component to a property in the plugin settings with optional automatic saving and value conversion.
  *
@@ -76,5 +81,5 @@ export declare function bindUiComponent<Plugin extends PluginBase<object>, TUICo
  *
  * @returns The `UIComponent` instance that was bound to the property.
  */
-export declare function bindUiComponent<Plugin extends PluginBase<object>, TUIComponent extends UIComponent<unknown>, Property extends keyof PluginSettings, UIValueType = TUIComponent extends UIComponent<infer P> ? P : never, PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never>(plugin: Plugin, uiComponent: TUIComponent, property: Property, options: BindUIComponentOptions<PluginSettings, Property, UIValueType>): TUIComponent;
+export declare function bindUiComponent<Plugin extends PluginBase<object>, TUIComponent extends UIComponent<unknown>, Property extends keyof PluginSettings, UIValueType = TUIComponent extends UIComponent<infer P> ? P : never, PluginSettings extends object = Plugin extends PluginBase<infer P> ? P : never>(plugin: Plugin, uiComponent: TUIComponent, property: Property, options: BindUIComponentOptionsExtended<PluginSettings, UIValueType, Property>): TUIComponent;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "2.20.0",
+  "version": "2.21.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development",
   "main": "./dist/lib/index.cjs",
   "types": "./dist/lib/index.d.ts",