obsidian-dev-utils 2.19.0 → 2.21.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 2.21.0
+
+- Handle default setting
+
+## 2.20.0
+
+- Pass plugin instead of tab
+
 ## 2.19.0
 
 - Refactor UIComponent

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

@@ -44,4 +44,4 @@ class PluginSettingsTabBase extends import_obsidian.PluginSettingTab {
 0 && (module.exports = {
   PluginSettingsTabBase
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -33,15 +33,19 @@ var __process = globalThis["process"] ?? {
   "env": {},
   "platform": "android"
 };
-function bindUiComponent(pluginSettingsTab, uiComponent, property, options) {
-  options ??= {
+function bindUiComponent(plugin, uiComponent, property, options) {
+  const DEFAULT_OPTIONS = {
+    autoSave: true,
     settingToUIValueConverter: (value) => value,
     uiToSettingValueConverter: (value) => value
   };
-  const pluginSettings = options.pluginSettings ?? pluginSettingsTab.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(pluginSettingsTab, uiComponent, property, options) {
         return;
       }
     }
-    pluginSettings[property] = options.uiToSettingValueConverter(uiValue);
-    if (options.autoSave ?? true) {
-      await pluginSettingsTab.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 { PluginSettingsTabBase } from \"./PluginSettingsTabBase.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 PluginSettingsTab - The type of the plugin settings tab that extends `PluginSettingsTabBase`.\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 TPlugin - The inferred type of the plugin that extends `PluginBase`.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param pluginSettingsTab - The plugin settings tab that contains the UI component.\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  PluginSettingsTab extends PluginSettingsTabBase<TPlugin, PluginSettings>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends KeysMatching<PluginSettings, UIValueType>,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  TPlugin extends PluginBase<PluginSettings> = PluginSettingsTab extends PluginSettingsTabBase<infer P> ? P : never,\n  PluginSettings extends object = TPlugin extends PluginBase<infer P> ? P : never,\n>(\n  pluginSettingsTab: PluginSettingsTab,\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 PluginSettingsTab - The type of the plugin settings tab that extends `PluginSettingsTabBase`.\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 TPlugin - The inferred type of the plugin that extends `PluginBase`.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param pluginSettingsTab - The plugin settings tab that contains the UI component.\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  PluginSettingsTab extends PluginSettingsTabBase<TPlugin, PluginSettings>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends keyof PluginSettings,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  TPlugin extends PluginBase<PluginSettings> = PluginSettingsTab extends PluginSettingsTabBase<infer P> ? P : never,\n  PluginSettings extends object = TPlugin extends PluginBase<infer P> ? P : never,\n>(\n  pluginSettingsTab: PluginSettingsTab,\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 PluginSettingsTab - The type of the plugin settings tab that extends `PluginSettingsTabBase`.\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 TPlugin - The inferred type of the plugin that extends `PluginBase`.\n * @typeParam PluginSettings - The inferred type of the plugin settings object.\n *\n * @param pluginSettingsTab - The plugin settings tab that contains the UI component.\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  PluginSettingsTab extends PluginSettingsTabBase<TPlugin, PluginSettings>,\n  TUIComponent extends UIComponent<unknown>,\n  Property extends keyof PluginSettings,\n  UIValueType = TUIComponent extends UIComponent<infer P> ? P : never,\n  TPlugin extends PluginBase<PluginSettings> = PluginSettingsTab extends PluginSettingsTabBase<infer P> ? P : never,\n  PluginSettings extends object = TPlugin extends PluginBase<infer P> ? P : never,\n>(\n  pluginSettingsTab: PluginSettingsTab,\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 ?? pluginSettingsTab.plugin.settingsCopy;\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 pluginSettingsTab.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;AASA,sBAKO;AAdP,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;AA6JO,SAAS,gBAQd,mBACA,aACA,UACA,SACc;AACd,cAAY;AAAA,IACV,2BAA2B,CAAC,UAAuB;AAAA,IACnD,2BAA2B,CAAC,UAAoC;AAAA,EAClE;AACA,QAAM,iBAAiB,QAAQ,kBAAkB,kBAAkB,OAAO;AAC1E,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,kBAAkB,OAAO,aAAa,cAAc;AAAA,IAC5D;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

@@ -1,5 +1,4 @@
 import type { KeysMatching } from "../../@types.ts";
-import type { PluginSettingsTabBase } from "./PluginSettingsTabBase.ts";
 import type { PluginBase } from "./PluginBase.ts";
 /**
  * A UI component that can be bound to a plugin setting.
@@ -19,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.
@@ -37,47 +47,39 @@ 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.
  *
- * @typeParam PluginSettingsTab - The type of the plugin settings tab that extends `PluginSettingsTabBase`.
+ * @typeParam Plugin - The type of the plugin that extends `PluginBase`.
  * @typeParam TUIComponent - The type of the value component extending `UIComponent`.
  * @typeParam Property - The key of the plugin setting that the component is bound to.
  * @typeParam UIValueType - The inferred type based on the UI component's type.
- * @typeParam TPlugin - The inferred type of the plugin that extends `PluginBase`.
  * @typeParam PluginSettings - The inferred type of the plugin settings object.
  *
- * @param pluginSettingsTab - The plugin settings tab that contains the UI component.
+ * @param plugin - The plugin.
  * @param uiComponent - The component that will display and interact with the setting value.
  * @param property - The property key in `PluginSettings` to bind to the UI component.
  * @param options - Configuration options.
  *
  * @returns The `UIComponent` instance that was bound to the property.
  */
-export declare function bindUiComponent<PluginSettingsTab extends PluginSettingsTabBase<TPlugin, PluginSettings>, TUIComponent extends UIComponent<unknown>, Property extends KeysMatching<PluginSettings, UIValueType>, UIValueType = TUIComponent extends UIComponent<infer P> ? P : never, TPlugin extends PluginBase<PluginSettings> = PluginSettingsTab extends PluginSettingsTabBase<infer P> ? P : never, PluginSettings extends object = TPlugin extends PluginBase<infer P> ? P : never>(pluginSettingsTab: PluginSettingsTab, 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.
  *
- * @typeParam PluginSettingsTab - The type of the plugin settings tab that extends `PluginSettingsTabBase`.
+ * @typeParam Plugin - The type of the plugin that extends `PluginBase`.
  * @typeParam TUIComponent - The type of the value component extending `UIComponent`.
  * @typeParam Property - The key of the plugin setting that the component is bound to.
  * @typeParam UIValueType - The inferred type based on the UI component's type.
- * @typeParam TPlugin - The inferred type of the plugin that extends `PluginBase`.
  * @typeParam PluginSettings - The inferred type of the plugin settings object.
  *
- * @param pluginSettingsTab - The plugin settings tab that contains the UI component.
+ * @param plugin - The plugin.
  * @param uiComponent - The component that will display and interact with the setting value.
  * @param property - The property key in `PluginSettings` to bind to the UI component.
  * @param options - Configuration options.
  *
  * @returns The `UIComponent` instance that was bound to the property.
  */
-export declare function bindUiComponent<PluginSettingsTab extends PluginSettingsTabBase<TPlugin, PluginSettings>, TUIComponent extends UIComponent<unknown>, Property extends keyof PluginSettings, UIValueType = TUIComponent extends UIComponent<infer P> ? P : never, TPlugin extends PluginBase<PluginSettings> = PluginSettingsTab extends PluginSettingsTabBase<infer P> ? P : never, PluginSettings extends object = TPlugin extends PluginBase<infer P> ? P : never>(pluginSettingsTab: PluginSettingsTab, 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.19.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",