obsidian-dev-utils 80.0.2 → 81.0.0

package/dist/lib/esm/obsidian/plugin/plugin-event-source.mjs

@@ -66,6 +66,8 @@ class PluginEventSourceImpl {
    * @param thisArg - The context passed as `this` to the `callback`.
    * @returns A reference to the event listener.
    *
+   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).
+   *
    * @example
    * ```ts
    * events.on('my-event', async (arg1, arg2) => {
@@ -88,6 +90,8 @@ class PluginEventSourceImpl {
    * @param thisArg - The context passed as `this` to the `callback`.
    * @returns A reference to the event listener.
    *
+   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).
+   *
    * @example
    * ```ts
    * events.once('my-event', async (arg1, arg2) => {
@@ -104,4 +108,4 @@ class PluginEventSourceImpl {
 export {
   PluginEventSourceImpl
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -64,6 +64,41 @@ export interface BindOptionsExtended<PluginSettings extends object, UIValue, Pro
      */
     pluginSettingsToComponentValueConverter(pluginSettingsValue: ReadonlyDeep<PluginSettings[PropertyName]>): UIValue;
 }
+/**
+ * Extended params for {@link PluginSettingsTabBase.bind} with value converters.
+ *
+ * @typeParam PluginSettings - The plugin settings type.
+ * @typeParam UIValue - The type of the UI component's value.
+ * @typeParam TValueComponent - The type of the value component.
+ * @typeParam PropertyName - The settings property name being bound.
+ */
+export interface PluginSettingsTabBaseBindExtendedParams<PluginSettings extends object, UIValue, TValueComponent, PropertyName extends StringKeys<PluginSettings>> extends BindOptionsExtended<PluginSettings, UIValue, PropertyName> {
+    /**
+     * The property name of the plugin settings to bind to.
+     */
+    readonly propertyName: PropertyName;
+    /**
+     * The value component to bind.
+     */
+    readonly valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>;
+}
+/**
+ * Params for {@link PluginSettingsTabBase.bind}.
+ *
+ * @typeParam PluginSettings - The plugin settings type.
+ * @typeParam UIValue - The type of the UI component's value.
+ * @typeParam TValueComponent - The type of the value component.
+ */
+export interface PluginSettingsTabBaseBindParams<PluginSettings extends object, UIValue, TValueComponent> extends BindOptions<UIValue> {
+    /**
+     * The property of the plugin settings to bind to.
+     */
+    readonly propertyName: ConditionalKeys<PluginSettings, UIValue>;
+    /**
+     * The value component to bind.
+     */
+    readonly valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>;
+}
 /**
  * Params for creating a {@link PluginSettingsTabBase}.
  *
@@ -121,24 +156,20 @@ export declare abstract class PluginSettingsTabBase<PluginSettings extends objec
      *
      * @typeParam UIValue - The type of the value of the UI component.
      * @typeParam TValueComponent - The type of the value component.
-     * @param valueComponent - The value component to bind.
-     * @param propertyName - The property of the plugin settings to bind to.
-     * @param options - The options for binding the value component.
+     * @param params - The params for binding the value component.
      * @returns The value component.
      */
-    bind<UIValue, TValueComponent>(valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>, propertyName: ConditionalKeys<PluginSettings, UIValue>, options?: BindOptions<UIValue>): TValueComponent;
+    bind<UIValue, TValueComponent>(params: PluginSettingsTabBaseBindParams<PluginSettings, UIValue, TValueComponent>): TValueComponent;
     /**
      * Binds a value component to a plugin setting.
      *
      * @typeParam UIValue - The type of the value of the UI component.
      * @typeParam TValueComponent - The type of the value component.
      * @typeParam PropertyName - The property name of the plugin settings to bind to.
-     * @param valueComponent - The value component to bind.
-     * @param propertyName - The property name of the plugin settings to bind to.
-     * @param options - The options for binding the value component.
+     * @param params - The params for binding the value component.
      * @returns The value component.
      */
-    bind<UIValue, TValueComponent, PropertyName extends StringKeys<PluginSettings>>(valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>, propertyName: PropertyName, options: BindOptionsExtended<PluginSettings, UIValue, PropertyName>): TValueComponent;
+    bind<UIValue, TValueComponent, PropertyName extends StringKeys<PluginSettings>>(params: PluginSettingsTabBaseBindExtendedParams<PluginSettings, UIValue, TValueComponent, PropertyName>): TValueComponent;
     /**
      * Renders the plugin settings tab.
      */

package/dist/lib/esm/obsidian/plugin/plugin-settings-tab.mjs

@@ -95,12 +95,15 @@ class PluginSettingsTabBase extends mixinAsyncEvents()(PluginSettingTab) {
    * @typeParam UIValue - The type of the value of the UI component.
    * @typeParam TValueComponent - The type of the value component.
    * @typeParam PropertyName - The property name of the plugin settings to bind to.
-   * @param valueComponent - The value component to bind.
-   * @param propertyName - The property name of the plugin settings to bind to.
-   * @param options - The options for binding the value component.
+   * @param params - The params for binding the value component.
    * @returns The value component.
    */
-  bind(valueComponent, propertyName, options) {
+  bind(params) {
+    const {
+      propertyName,
+      valueComponent,
+      ...options
+    } = params;
     const DEFAULT_OPTIONS = {
       componentToPluginSettingsValueConverter: (value) => value,
       onChanged: noop,
@@ -252,7 +255,7 @@ class PluginSettingsTabBase extends mixinAsyncEvents()(PluginSettingTab) {
     this._isOpen = true;
     this.component.load();
     registerAsyncEvent(this.component, this.pluginSettingsComponent.on("loadSettings", this.onLoadSettings.bind(this)));
-    registerAsyncEvent(this.component, this.pluginSettingsComponent.on("saveSettings", this.onSaveSettings.bind(this)));
+    registerAsyncEvent(this.component, this.pluginSettingsComponent.on("saveSettings", (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));
   }
   /**
    * Hides the plugin settings tab.
@@ -302,7 +305,12 @@ class PluginSettingsTabBase extends mixinAsyncEvents()(PluginSettingTab) {
     const settings = this.pluginSettings;
     return settings[propertyName];
   }
-  async onSaveSettings(newState, _oldState, context) {
+  async onSaveSettings(params) {
+    const {
+      context,
+      newState,
+      oldState: _oldState
+    } = params;
     if (context === SAVE_TO_FILE_CONTEXT) {
       await this.updateValidations(newState.validationMessages);
       return;
@@ -319,4 +327,4 @@ export {
   PluginSettingsTabBase,
   SAVE_TO_FILE_CONTEXT
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin-settings-tab.ts"],
  "sourcesContent": ["/**\n * @file\n *\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  Debouncer,\n  Plugin\n} from 'obsidian';\nimport type {\n  ConditionalKeys,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport {\n  debounce,\n  PluginSettingTab,\n  setTooltip\n} from 'obsidian';\n\nimport type { StringKeys } from '../../type.ts';\nimport type {\n  PluginSettingsComponentBase,\n  ReadonlyPluginSettings,\n  ReadonlyPluginSettingsState\n} from '../components/plugin-settings-component.ts';\nimport type { ValueComponentWithChangeTracking } from '../setting-components/value-component-with-change-tracking.ts';\nimport type { ValidationMessageHolder } from '../validation.ts';\n\nimport { mixinAsyncEvents } from '../../async-events.ts';\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../async.ts';\nimport { CssClass } from '../../css-class.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport { deepEqual } from '../../object-utils.ts';\nimport { assertNonNullable } from '../../type-guards.ts';\nimport { registerAsyncEvent } from '../components/async-events-component.ts';\nimport { ComponentEx } from '../components/component-ex.ts';\nimport { ensureWrapped } from '../setting-components/setting-component-wrapper.ts';\nimport { getTextBasedComponentValue } from '../setting-components/text-based-component.ts';\nimport { getValidatorComponent } from '../setting-components/validator-component.ts';\nimport { isValidationMessageHolder } from '../validation.ts';\nimport { addPluginCssClasses } from './plugin-context.ts';\n\n/**\n * A context passed to the {@link PluginSettingsComponentBase.saveToFile} method.\n */\nexport const SAVE_TO_FILE_CONTEXT = 'PluginSettingsTab';\n\n/**\n * Options for `PluginSettingsTabBase.bind`.\n *\n * @typeParam T - The type of the settings property value.\n */\nexport interface BindOptions<T> {\n  /**\n   * A callback function that is called when the value of the component changes.\n   */\n  onChanged?(newValue: ReadonlyDeep<T>, oldValue: ReadonlyDeep<T>): Promisable<void>;\n\n  /**\n   * Whether to reset the setting when the component value is empty. Default is `true`.\n   * Applicable only to text-based components.\n   */\n  readonly shouldResetSettingWhenComponentIsEmpty?: boolean;\n\n  /**\n   * Whether to show the placeholder for default values. Default is `true`.\n   * Applicable only to text-based components.\n   */\n  readonly shouldShowPlaceholderForDefaultValues?: boolean;\n\n  /**\n   * Whether to show the validation message when the component value is invalid. Default is `true`.\n   */\n  readonly shouldShowValidationMessage?: boolean;\n}\n\n/**\n * Extended options for `PluginSettingsTabBase.bind`.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam PropertyName - The settings property name being bound.\n */\nexport interface BindOptionsExtended<\n  PluginSettings extends object,\n  UIValue,\n  PropertyName extends StringKeys<PluginSettings>\n> extends BindOptions<PluginSettings[PropertyName]> {\n  /**\n   * Converts the UI component's value back to the plugin settings value.\n   *\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[PropertyName] | ValidationMessageHolder;\n\n  /**\n   * Converts the plugin settings value to the value used by the UI component.\n   *\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: ReadonlyDeep<PluginSettings[PropertyName]>): UIValue;\n}\n\n/**\n * Params for creating a {@link PluginSettingsTabBase}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\nexport interface PluginSettingsTabBaseConstructorParams<PluginSettings extends object> {\n  /**\n   * The plugin instance (needed by Obsidian's PluginSettingTab).\n   */\n  readonly plugin: Plugin;\n\n  /**\n   * The settings component.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<PluginSettings>;\n}\n\ninterface PluginSettingsTabBaseEventMap {\n  validationMessageChanged: [propertyName: string, 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 PluginSettings - The plugin settings type.\n */\nexport abstract class PluginSettingsTabBase<PluginSettings extends object> extends mixinAsyncEvents<PluginSettingsTabBaseEventMap>()(PluginSettingTab) {\n  /**\n   * Whether the plugin settings tab is open.\n   *\n   * @returns Whether the plugin settings tab is open.\n   */\n  public get isOpen(): boolean {\n    return this._isOpen;\n  }\n\n  /**\n   * The settings manager.\n   */\n  protected readonly pluginSettingsComponent: PluginSettingsComponentBase<PluginSettings>;\n\n  /**\n   * A debounce timeout for saving settings.\n   *\n   * @returns The debounce timeout for saving settings.\n   */\n  protected get saveSettingsDebounceTimeoutInMilliseconds(): number {\n    const DEFAULT = 2_000;\n    return DEFAULT;\n  }\n\n  private _isOpen = false;\n  private readonly component: ComponentEx;\n  private readonly saveSettingsDebounced: Debouncer<[], void>;\n\n  private get pluginSettings(): ReadonlyPluginSettings<PluginSettings> {\n    return this.pluginSettingsComponent.settingsState.inputValues;\n  }\n\n  /**\n   * Creates a new plugin settings tab.\n   *\n   * @param params - The params.\n   */\n  public constructor(params: PluginSettingsTabBaseConstructorParams<PluginSettings>) {\n    super(params.plugin.app, params.plugin);\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    addPluginCssClasses(this.containerEl, CssClass.PluginSettingsTab);\n    this.saveSettingsDebounced = debounce(\n      convertAsyncToSync(() => this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT)),\n      this.saveSettingsDebounceTimeoutInMilliseconds\n    );\n    this.component = new ComponentEx();\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 propertyName - 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    propertyName: ConditionalKeys<PluginSettings, 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 PropertyName - The property name of the plugin settings to bind to.\n   * @param valueComponent - The value component to bind.\n   * @param propertyName - The property name 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    PropertyName extends StringKeys<PluginSettings>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: PropertyName,\n    options: BindOptionsExtended<PluginSettings, UIValue, PropertyName>\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 PropertyName - The property name of the plugin settings to bind to.\n   * @param valueComponent - The value component to bind.\n   * @param propertyName - The property name 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    PropertyName extends StringKeys<PluginSettings>\n  >(\n    valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>,\n    propertyName: PropertyName,\n    options?: BindOptions<PluginSettings[PropertyName]> // eslint-disable-line obsidian-dev-utils/params-options-name-match -- BindOptions is a generic utility shared across binding methods.\n  ): TValueComponent {\n    type PropertyType = PluginSettings[PropertyName];\n    const DEFAULT_OPTIONS: Required<BindOptionsExtended<PluginSettings, UIValue, PropertyName>> = {\n      componentToPluginSettingsValueConverter: (value: UIValue): PropertyType => value as PropertyType,\n      onChanged: noop,\n      pluginSettingsToComponentValueConverter: (value: ReadonlyDeep<PropertyType>): UIValue => value as UIValue,\n      shouldResetSettingWhenComponentIsEmpty: true,\n      shouldShowPlaceholderForDefaultValues: true,\n      shouldShowValidationMessage: true\n    };\n\n    const optionsExt: Required<BindOptionsExtended<PluginSettings, UIValue, PropertyName>> = { ...DEFAULT_OPTIONS, ...options };\n\n    const validatorEl = getValidatorComponent(valueComponent)?.validatorEl;\n\n    const textBasedComponent = getTextBasedComponentValue(valueComponent);\n\n    const readonlyValue = this.getPluginSettingsProperty(propertyName);\n    const defaults = this.pluginSettingsComponent.defaultSettings as PluginSettings;\n    const defaultValue = defaults[propertyName];\n    const defaultComponentValue = optionsExt.pluginSettingsToComponentValueConverter(defaultValue as ReadonlyDeep<PropertyType>);\n    textBasedComponent?.setPlaceholderValue(defaultComponentValue);\n\n    let validationMessage: string;\n    let tooltipEl: HTMLElement | null = null;\n    let tooltipContentEl: HTMLElement | null = null;\n    if (validatorEl) {\n      const wrapper = ensureWrapped(validatorEl);\n      tooltipEl = wrapper.createDiv();\n      addPluginCssClasses(tooltipEl, [CssClass.Tooltip, CssClass.TooltipValidator]);\n      tooltipContentEl = tooltipEl.createSpan();\n      const tooltipArrowEl = tooltipEl.createDiv();\n      addPluginCssClasses(tooltipArrowEl, CssClass.TooltipArrow);\n      tooltipEl.hide();\n      wrapper.appendChild(tooltipEl);\n    }\n\n    registerAsyncEvent(\n      this.component,\n      this.on('validationMessageChanged', (anotherPropertyName, anotherValidationMessage) => {\n        if (propertyName !== anotherPropertyName) {\n          return;\n        }\n\n        validationMessage = anotherValidationMessage;\n        updateValidatorElDebounced();\n      })\n    );\n\n    let shouldEmptyOnBlur = false;\n    let shouldRevertToDefaultValueOnBlur = false;\n\n    if (textBasedComponent && optionsExt.shouldShowPlaceholderForDefaultValues && deepEqual(readonlyValue, defaultValue)) {\n      textBasedComponent.empty();\n    } else {\n      valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(readonlyValue));\n    }\n\n    let shouldSkipOnChange = false;\n    const UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS = 100;\n    const updateValidatorElDebounced = debounce(() => {\n      window.requestAnimationFrame(() => {\n        updateValidatorEl();\n      });\n    }, UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS);\n\n    valueComponent.onChange(convertAsyncToSync(async (uiValue) => {\n      if (shouldSkipOnChange) {\n        shouldSkipOnChange = false;\n        return;\n      }\n\n      shouldEmptyOnBlur = false;\n\n      const oldValue = this.getPluginSettingsProperty(propertyName);\n      let newValue: PropertyType | undefined = undefined;\n      let shouldSetProperty = true;\n      shouldRevertToDefaultValueOnBlur = !!textBasedComponent?.isEmpty() && optionsExt.shouldResetSettingWhenComponentIsEmpty;\n      if (shouldRevertToDefaultValueOnBlur) {\n        newValue = defaultValue;\n      } else {\n        const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);\n        if (isValidationMessageHolder(convertedValue)) {\n          validationMessage = convertedValue.validationMessage;\n          shouldSetProperty = false;\n        } else {\n          newValue = convertedValue;\n        }\n      }\n\n      if (shouldSetProperty) {\n        validationMessage = await this.pluginSettingsComponent.setProperty(propertyName, newValue as PluginSettings[PropertyName]);\n        if (textBasedComponent && optionsExt.shouldShowPlaceholderForDefaultValues && !textBasedComponent.isEmpty() && deepEqual(newValue, defaultValue)) {\n          shouldEmptyOnBlur = true;\n        }\n      }\n\n      updateValidatorElDebounced();\n      if (shouldSetProperty) {\n        await optionsExt.onChanged(newValue as ReadonlyDeep<PropertyType>, oldValue);\n      }\n      this.saveSettingsDebounced();\n    }));\n\n    validatorEl?.addEventListener('focus', () => {\n      updateValidatorElDebounced();\n    });\n    validatorEl?.addEventListener('blur', () => {\n      updateValidatorElDebounced();\n    });\n    validatorEl?.addEventListener('click', () => {\n      window.requestAnimationFrame(() => {\n        updateValidatorElDebounced();\n      });\n    });\n\n    const validationMessages = this.pluginSettingsComponent.settingsState.validationMessages as Record<string, string>;\n    validationMessage = validationMessages[propertyName] ?? '';\n    updateValidatorElDebounced();\n\n    return valueComponent;\n\n    function updateValidatorEl(): void {\n      if (!validatorEl?.isActiveElement()) {\n        if (shouldEmptyOnBlur) {\n          shouldEmptyOnBlur = false;\n\n          if (!textBasedComponent?.isEmpty()) {\n            shouldSkipOnChange = true;\n            textBasedComponent?.empty();\n          }\n        } else if (shouldRevertToDefaultValueOnBlur) {\n          shouldRevertToDefaultValueOnBlur = false;\n\n          if (textBasedComponent?.isEmpty()) {\n            shouldSkipOnChange = true;\n            valueComponent.setValue(defaultComponentValue);\n          }\n        }\n      }\n\n      if (!validatorEl) {\n        return;\n      }\n\n      assertNonNullable(tooltipContentEl);\n\n      if (validationMessage === '') {\n        validatorEl.setCustomValidity('');\n        validatorEl.checkValidity();\n        validationMessage = validatorEl.validationMessage;\n      }\n\n      validatorEl.setCustomValidity(validationMessage);\n      if (optionsExt.shouldShowValidationMessage) {\n        tooltipContentEl.textContent = validationMessage;\n        tooltipEl?.toggle(!!validationMessage);\n      } else if (validationMessage) {\n        setTooltip(validatorEl, validationMessage);\n      }\n    }\n  }\n\n  /**\n   * Renders the plugin settings tab.\n   */\n  public override display(): void {\n    this.displayLegacy();\n  }\n\n  /**\n   * Legacy way to render the plugin settings tab.\n   *\n   * Temporary workaround to avoid dealing with `@deprecated`.\n   */\n  public displayLegacy(): void {\n    this.containerEl.empty();\n    this._isOpen = true;\n    this.component.load();\n    registerAsyncEvent(this.component, this.pluginSettingsComponent.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this.component, this.pluginSettingsComponent.on('saveSettings', this.onSaveSettings.bind(this)));\n  }\n\n  /**\n   * Hides the plugin settings tab.\n   */\n  public override hide(): void {\n    super.hide();\n    this.saveSettingsDebounced.cancel();\n    this._isOpen = false;\n    this.component.unload();\n    invokeAsyncSafely(() => this.hideAsync());\n  }\n\n  /**\n   * Async actions to perform when the settings tab is being hidden.\n   *\n   * @returns A {@link Promise} that resolves when the settings tab is hidden.\n   */\n  public async hideAsync(): Promise<void> {\n    await this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT);\n  }\n\n  /**\n   * Shows the plugin settings tab.\n   */\n  public show(): void {\n    this.app.setting.openTab(this);\n  }\n\n  /**\n   * Called when the plugin settings are loaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether the settings are being loaded for the first time.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  protected async onLoadSettings(_loadedState: ReadonlyPluginSettingsState<PluginSettings>, _isInitialLoad: boolean): Promise<void> {\n    this.displayLegacy();\n    await noopAsync();\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns A {@link Promise} that resolves when the settings are revalidated.\n   */\n  protected async revalidate(): Promise<void> {\n    const validationMessages = await this.pluginSettingsComponent.revalidate();\n    await this.updateValidations(validationMessages);\n  }\n\n  private getPluginSettingsProperty<PropertyName extends StringKeys<PluginSettings>>(\n    propertyName: PropertyName\n  ): ReadonlyDeep<PluginSettings[PropertyName]> {\n    const settings = this.pluginSettings as PluginSettings;\n    return settings[propertyName] as ReadonlyDeep<PluginSettings[PropertyName]>;\n  }\n\n  private async onSaveSettings(\n    newState: ReadonlyPluginSettingsState<PluginSettings>,\n    _oldState: ReadonlyPluginSettingsState<PluginSettings>,\n    context: unknown\n  ): Promise<void> {\n    if (context === SAVE_TO_FILE_CONTEXT) {\n      await this.updateValidations(newState.validationMessages as Record<StringKeys<PluginSettings>, string>);\n      return;\n    }\n\n    this.displayLegacy();\n  }\n\n  private async updateValidations(validationMessages: Record<StringKeys<PluginSettings>, string>): Promise<void> {\n    for (const [propertyName, validationMessage] of Object.entries(validationMessages)) {\n      await this.triggerAsync('validationMessageChanged', propertyName, validationMessage as string);\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin-settings-tab.ts"],
  "sourcesContent": ["/**\n * @file\n *\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  Debouncer,\n  Plugin\n} from 'obsidian';\nimport type {\n  ConditionalKeys,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport {\n  debounce,\n  PluginSettingTab,\n  setTooltip\n} from 'obsidian';\n\nimport type { StringKeys } from '../../type.ts';\nimport type {\n  PluginSettingsComponentBase,\n  ReadonlyPluginSettings,\n  ReadonlyPluginSettingsState\n} from '../components/plugin-settings-component.ts';\nimport type { ValueComponentWithChangeTracking } from '../setting-components/value-component-with-change-tracking.ts';\nimport type { ValidationMessageHolder } from '../validation.ts';\n\nimport { mixinAsyncEvents } from '../../async-events.ts';\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../async.ts';\nimport { CssClass } from '../../css-class.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport { deepEqual } from '../../object-utils.ts';\nimport { assertNonNullable } from '../../type-guards.ts';\nimport { registerAsyncEvent } from '../components/async-events-component.ts';\nimport { ComponentEx } from '../components/component-ex.ts';\nimport { ensureWrapped } from '../setting-components/setting-component-wrapper.ts';\nimport { getTextBasedComponentValue } from '../setting-components/text-based-component.ts';\nimport { getValidatorComponent } from '../setting-components/validator-component.ts';\nimport { isValidationMessageHolder } from '../validation.ts';\nimport { addPluginCssClasses } from './plugin-context.ts';\n\n/**\n * A context passed to the {@link PluginSettingsComponentBase.saveToFile} method.\n */\nexport const SAVE_TO_FILE_CONTEXT = 'PluginSettingsTab';\n\n/**\n * Options for `PluginSettingsTabBase.bind`.\n *\n * @typeParam T - The type of the settings property value.\n */\nexport interface BindOptions<T> {\n  /**\n   * A callback function that is called when the value of the component changes.\n   */\n  onChanged?(newValue: ReadonlyDeep<T>, oldValue: ReadonlyDeep<T>): Promisable<void>;\n\n  /**\n   * Whether to reset the setting when the component value is empty. Default is `true`.\n   * Applicable only to text-based components.\n   */\n  readonly shouldResetSettingWhenComponentIsEmpty?: boolean;\n\n  /**\n   * Whether to show the placeholder for default values. Default is `true`.\n   * Applicable only to text-based components.\n   */\n  readonly shouldShowPlaceholderForDefaultValues?: boolean;\n\n  /**\n   * Whether to show the validation message when the component value is invalid. Default is `true`.\n   */\n  readonly shouldShowValidationMessage?: boolean;\n}\n\n/**\n * Extended options for `PluginSettingsTabBase.bind`.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam PropertyName - The settings property name being bound.\n */\nexport interface BindOptionsExtended<\n  PluginSettings extends object,\n  UIValue,\n  PropertyName extends StringKeys<PluginSettings>\n> extends BindOptions<PluginSettings[PropertyName]> {\n  /**\n   * Converts the UI component's value back to the plugin settings value.\n   *\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[PropertyName] | ValidationMessageHolder;\n\n  /**\n   * Converts the plugin settings value to the value used by the UI component.\n   *\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: ReadonlyDeep<PluginSettings[PropertyName]>): UIValue;\n}\n\n/**\n * Extended params for {@link PluginSettingsTabBase.bind} with value converters.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam TValueComponent - The type of the value component.\n * @typeParam PropertyName - The settings property name being bound.\n */\nexport interface PluginSettingsTabBaseBindExtendedParams<\n  PluginSettings extends object,\n  UIValue,\n  TValueComponent,\n  PropertyName extends StringKeys<PluginSettings>\n> extends BindOptionsExtended<PluginSettings, UIValue, PropertyName> {\n  /**\n   * The property name of the plugin settings to bind to.\n   */\n  readonly propertyName: PropertyName;\n\n  /**\n   * The value component to bind.\n   */\n  readonly valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>;\n}\n\n/**\n * Params for {@link PluginSettingsTabBase.bind}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam TValueComponent - The type of the value component.\n */\nexport interface PluginSettingsTabBaseBindParams<\n  PluginSettings extends object,\n  UIValue,\n  TValueComponent\n> extends BindOptions<UIValue> {\n  /**\n   * The property of the plugin settings to bind to.\n   */\n  readonly propertyName: ConditionalKeys<PluginSettings, UIValue>;\n\n  /**\n   * The value component to bind.\n   */\n  readonly valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>;\n}\n\n/**\n * Params for creating a {@link PluginSettingsTabBase}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\nexport interface PluginSettingsTabBaseConstructorParams<PluginSettings extends object> {\n  /**\n   * The plugin instance (needed by Obsidian's PluginSettingTab).\n   */\n  readonly plugin: Plugin;\n\n  /**\n   * The settings component.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<PluginSettings>;\n}\n\n/**\n * Implementation params for {@link PluginSettingsTabBase.bind}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam UIValue - The type of the UI component's value.\n * @typeParam TValueComponent - The type of the value component.\n * @typeParam PropertyName - The settings property name being bound.\n */\ninterface PluginSettingsTabBaseBindImplParams<\n  PluginSettings extends object,\n  UIValue,\n  TValueComponent,\n  PropertyName extends StringKeys<PluginSettings>\n> extends BindOptions<PluginSettings[PropertyName]> {\n  /**\n   * The property name of the plugin settings to bind to.\n   */\n  readonly propertyName: PropertyName;\n\n  /**\n   * The value component to bind.\n   */\n  readonly valueComponent: TValueComponent & ValueComponentWithChangeTracking<UIValue>;\n}\n\ninterface PluginSettingsTabBaseEventMap {\n  validationMessageChanged: [propertyName: string, validationMessage: string];\n}\n\n/**\n * Parameters for {@link PluginSettingsTabBase.onSaveSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\ninterface PluginSettingsTabBaseOnSaveSettingsParams<PluginSettings extends object> {\n  /**\n   * The save context.\n   */\n  readonly context: unknown;\n\n  /**\n   * The new settings state.\n   */\n  readonly newState: ReadonlyPluginSettingsState<PluginSettings>;\n\n  /**\n   * The old settings state.\n   */\n  readonly oldState: ReadonlyPluginSettingsState<PluginSettings>;\n}\n\n/**\n * 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 PluginSettings - The plugin settings type.\n */\nexport abstract class PluginSettingsTabBase<PluginSettings extends object> extends mixinAsyncEvents<PluginSettingsTabBaseEventMap>()(PluginSettingTab) {\n  /**\n   * Whether the plugin settings tab is open.\n   *\n   * @returns Whether the plugin settings tab is open.\n   */\n  public get isOpen(): boolean {\n    return this._isOpen;\n  }\n\n  /**\n   * The settings manager.\n   */\n  protected readonly pluginSettingsComponent: PluginSettingsComponentBase<PluginSettings>;\n\n  /**\n   * A debounce timeout for saving settings.\n   *\n   * @returns The debounce timeout for saving settings.\n   */\n  protected get saveSettingsDebounceTimeoutInMilliseconds(): number {\n    const DEFAULT = 2_000;\n    return DEFAULT;\n  }\n\n  private _isOpen = false;\n  private readonly component: ComponentEx;\n  private readonly saveSettingsDebounced: Debouncer<[], void>;\n\n  private get pluginSettings(): ReadonlyPluginSettings<PluginSettings> {\n    return this.pluginSettingsComponent.settingsState.inputValues;\n  }\n\n  /**\n   * Creates a new plugin settings tab.\n   *\n   * @param params - The params.\n   */\n  public constructor(params: PluginSettingsTabBaseConstructorParams<PluginSettings>) {\n    super(params.plugin.app, params.plugin);\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    addPluginCssClasses(this.containerEl, CssClass.PluginSettingsTab);\n    this.saveSettingsDebounced = debounce(\n      convertAsyncToSync(() => this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT)),\n      this.saveSettingsDebounceTimeoutInMilliseconds\n    );\n    this.component = new ComponentEx();\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 params - The params for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent\n  >(\n    params: PluginSettingsTabBaseBindParams<PluginSettings, UIValue, TValueComponent>\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 PropertyName - The property name of the plugin settings to bind to.\n   * @param params - The params for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    PropertyName extends StringKeys<PluginSettings>\n  >(\n    params: PluginSettingsTabBaseBindExtendedParams<PluginSettings, UIValue, TValueComponent, PropertyName>\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 PropertyName - The property name of the plugin settings to bind to.\n   * @param params - The params for binding the value component.\n   * @returns The value component.\n   */\n  public bind<\n    UIValue,\n    TValueComponent,\n    PropertyName extends StringKeys<PluginSettings>\n  >(\n    params: PluginSettingsTabBaseBindImplParams<PluginSettings, UIValue, TValueComponent, PropertyName> // eslint-disable-line obsidian-dev-utils/params-options-name-match -- bind overload shares the Bind* param family.\n  ): TValueComponent {\n    const {\n      propertyName,\n      valueComponent,\n      ...options\n    } = params;\n    type PropertyType = PluginSettings[PropertyName];\n    const DEFAULT_OPTIONS: Required<BindOptionsExtended<PluginSettings, UIValue, PropertyName>> = {\n      componentToPluginSettingsValueConverter: (value: UIValue): PropertyType => value as PropertyType,\n      onChanged: noop,\n      pluginSettingsToComponentValueConverter: (value: ReadonlyDeep<PropertyType>): UIValue => value as UIValue,\n      shouldResetSettingWhenComponentIsEmpty: true,\n      shouldShowPlaceholderForDefaultValues: true,\n      shouldShowValidationMessage: true\n    };\n\n    const optionsExt: Required<BindOptionsExtended<PluginSettings, UIValue, PropertyName>> = { ...DEFAULT_OPTIONS, ...options };\n\n    const validatorEl = getValidatorComponent(valueComponent)?.validatorEl;\n\n    const textBasedComponent = getTextBasedComponentValue(valueComponent);\n\n    const readonlyValue = this.getPluginSettingsProperty(propertyName);\n    const defaults = this.pluginSettingsComponent.defaultSettings as PluginSettings;\n    const defaultValue = defaults[propertyName];\n    const defaultComponentValue = optionsExt.pluginSettingsToComponentValueConverter(defaultValue as ReadonlyDeep<PropertyType>);\n    textBasedComponent?.setPlaceholderValue(defaultComponentValue);\n\n    let validationMessage: string;\n    let tooltipEl: HTMLElement | null = null;\n    let tooltipContentEl: HTMLElement | null = null;\n    if (validatorEl) {\n      const wrapper = ensureWrapped(validatorEl);\n      tooltipEl = wrapper.createDiv();\n      addPluginCssClasses(tooltipEl, [CssClass.Tooltip, CssClass.TooltipValidator]);\n      tooltipContentEl = tooltipEl.createSpan();\n      const tooltipArrowEl = tooltipEl.createDiv();\n      addPluginCssClasses(tooltipArrowEl, CssClass.TooltipArrow);\n      tooltipEl.hide();\n      wrapper.appendChild(tooltipEl);\n    }\n\n    registerAsyncEvent(\n      this.component,\n      this.on('validationMessageChanged', (anotherPropertyName, anotherValidationMessage) => {\n        if (propertyName !== anotherPropertyName) {\n          return;\n        }\n\n        validationMessage = anotherValidationMessage;\n        updateValidatorElDebounced();\n      })\n    );\n\n    let shouldEmptyOnBlur = false;\n    let shouldRevertToDefaultValueOnBlur = false;\n\n    if (textBasedComponent && optionsExt.shouldShowPlaceholderForDefaultValues && deepEqual(readonlyValue, defaultValue)) {\n      textBasedComponent.empty();\n    } else {\n      valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(readonlyValue));\n    }\n\n    let shouldSkipOnChange = false;\n    const UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS = 100;\n    const updateValidatorElDebounced = debounce(() => {\n      window.requestAnimationFrame(() => {\n        updateValidatorEl();\n      });\n    }, UPDATE_VALIDATOR_EL_TIMEOUT_IN_MILLISECONDS);\n\n    valueComponent.onChange(convertAsyncToSync(async (uiValue) => {\n      if (shouldSkipOnChange) {\n        shouldSkipOnChange = false;\n        return;\n      }\n\n      shouldEmptyOnBlur = false;\n\n      const oldValue = this.getPluginSettingsProperty(propertyName);\n      let newValue: PropertyType | undefined = undefined;\n      let shouldSetProperty = true;\n      shouldRevertToDefaultValueOnBlur = !!textBasedComponent?.isEmpty() && optionsExt.shouldResetSettingWhenComponentIsEmpty;\n      if (shouldRevertToDefaultValueOnBlur) {\n        newValue = defaultValue;\n      } else {\n        const convertedValue = optionsExt.componentToPluginSettingsValueConverter(uiValue);\n        if (isValidationMessageHolder(convertedValue)) {\n          validationMessage = convertedValue.validationMessage;\n          shouldSetProperty = false;\n        } else {\n          newValue = convertedValue;\n        }\n      }\n\n      if (shouldSetProperty) {\n        validationMessage = await this.pluginSettingsComponent.setProperty(propertyName, newValue as PluginSettings[PropertyName]);\n        if (textBasedComponent && optionsExt.shouldShowPlaceholderForDefaultValues && !textBasedComponent.isEmpty() && deepEqual(newValue, defaultValue)) {\n          shouldEmptyOnBlur = true;\n        }\n      }\n\n      updateValidatorElDebounced();\n      if (shouldSetProperty) {\n        await optionsExt.onChanged(newValue as ReadonlyDeep<PropertyType>, oldValue);\n      }\n      this.saveSettingsDebounced();\n    }));\n\n    validatorEl?.addEventListener('focus', () => {\n      updateValidatorElDebounced();\n    });\n    validatorEl?.addEventListener('blur', () => {\n      updateValidatorElDebounced();\n    });\n    validatorEl?.addEventListener('click', () => {\n      window.requestAnimationFrame(() => {\n        updateValidatorElDebounced();\n      });\n    });\n\n    const validationMessages = this.pluginSettingsComponent.settingsState.validationMessages as Record<string, string>;\n    validationMessage = validationMessages[propertyName] ?? '';\n    updateValidatorElDebounced();\n\n    return valueComponent;\n\n    function updateValidatorEl(): void {\n      if (!validatorEl?.isActiveElement()) {\n        if (shouldEmptyOnBlur) {\n          shouldEmptyOnBlur = false;\n\n          if (!textBasedComponent?.isEmpty()) {\n            shouldSkipOnChange = true;\n            textBasedComponent?.empty();\n          }\n        } else if (shouldRevertToDefaultValueOnBlur) {\n          shouldRevertToDefaultValueOnBlur = false;\n\n          if (textBasedComponent?.isEmpty()) {\n            shouldSkipOnChange = true;\n            valueComponent.setValue(defaultComponentValue);\n          }\n        }\n      }\n\n      if (!validatorEl) {\n        return;\n      }\n\n      assertNonNullable(tooltipContentEl);\n\n      if (validationMessage === '') {\n        validatorEl.setCustomValidity('');\n        validatorEl.checkValidity();\n        validationMessage = validatorEl.validationMessage;\n      }\n\n      validatorEl.setCustomValidity(validationMessage);\n      if (optionsExt.shouldShowValidationMessage) {\n        tooltipContentEl.textContent = validationMessage;\n        tooltipEl?.toggle(!!validationMessage);\n      } else if (validationMessage) {\n        setTooltip(validatorEl, validationMessage);\n      }\n    }\n  }\n\n  /**\n   * Renders the plugin settings tab.\n   */\n  public override display(): void {\n    this.displayLegacy();\n  }\n\n  /**\n   * Legacy way to render the plugin settings tab.\n   *\n   * Temporary workaround to avoid dealing with `@deprecated`.\n   */\n  public displayLegacy(): void {\n    this.containerEl.empty();\n    this._isOpen = true;\n    this.component.load();\n    registerAsyncEvent(this.component, this.pluginSettingsComponent.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this.component, this.pluginSettingsComponent.on('saveSettings', (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));\n  }\n\n  /**\n   * Hides the plugin settings tab.\n   */\n  public override hide(): void {\n    super.hide();\n    this.saveSettingsDebounced.cancel();\n    this._isOpen = false;\n    this.component.unload();\n    invokeAsyncSafely(() => this.hideAsync());\n  }\n\n  /**\n   * Async actions to perform when the settings tab is being hidden.\n   *\n   * @returns A {@link Promise} that resolves when the settings tab is hidden.\n   */\n  public async hideAsync(): Promise<void> {\n    await this.pluginSettingsComponent.saveToFile(SAVE_TO_FILE_CONTEXT);\n  }\n\n  /**\n   * Shows the plugin settings tab.\n   */\n  public show(): void {\n    this.app.setting.openTab(this);\n  }\n\n  /**\n   * Called when the plugin settings are loaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether the settings are being loaded for the first time.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  protected async onLoadSettings(_loadedState: ReadonlyPluginSettingsState<PluginSettings>, _isInitialLoad: boolean): Promise<void> {\n    this.displayLegacy();\n    await noopAsync();\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns A {@link Promise} that resolves when the settings are revalidated.\n   */\n  protected async revalidate(): Promise<void> {\n    const validationMessages = await this.pluginSettingsComponent.revalidate();\n    await this.updateValidations(validationMessages);\n  }\n\n  private getPluginSettingsProperty<PropertyName extends StringKeys<PluginSettings>>(\n    propertyName: PropertyName\n  ): ReadonlyDeep<PluginSettings[PropertyName]> {\n    const settings = this.pluginSettings as PluginSettings;\n    return settings[propertyName] as ReadonlyDeep<PluginSettings[PropertyName]>;\n  }\n\n  private async onSaveSettings(params: PluginSettingsTabBaseOnSaveSettingsParams<PluginSettings>): Promise<void> {\n    const {\n      context,\n      newState,\n      oldState: _oldState\n    } = params;\n    if (context === SAVE_TO_FILE_CONTEXT) {\n      await this.updateValidations(newState.validationMessages as Record<StringKeys<PluginSettings>, string>);\n      return;\n    }\n\n    this.displayLegacy();\n  }\n\n  private async updateValidations(validationMessages: Record<StringKeys<PluginSettings>, string>): Promise<void> {\n    for (const [propertyName, validationMessage] of Object.entries(validationMessages)) {\n      await this.triggerAsync('validationMessageChanged', propertyName, validationMessage as string);\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -8,7 +8,7 @@
  */
 import type { Component } from 'obsidian';
 import type { Promisable } from 'type-fest';
-import { Plugin as ObsidianPlugin } from 'obsidian';
+import { Plugin } from 'obsidian';
 import type { TranslationsMap } from '../i18n/i18n.mjs';
 import type { PluginEventMap, PluginEventSource } from './plugin-event-source.mjs';
 import { AbortSignalComponent } from '../components/abort-signal-component.mjs';
@@ -16,7 +16,7 @@ import { AsyncErrorHandlerComponent } from '../components/async-error-handler-co
 import { ConsoleDebugComponent } from '../components/console-debug-component.mjs';
 import { PluginContextComponent } from '../components/plugin-context-component.mjs';
 import { PluginNoticeComponent } from '../components/plugin-notice-component.mjs';
-declare const PluginBase_base: import("type-fest").AbstractConstructor<import("../../async-events.mjs").AsyncEventSource<PluginEventMap> & import("../../async-events.mjs").AsyncEventTrigger<PluginEventMap>> & typeof ObsidianPlugin;
+declare const PluginBase_base: import("type-fest").AbstractConstructor<import("../../async-events.mjs").AsyncEventSource<PluginEventMap> & import("../../async-events.mjs").AsyncEventTrigger<PluginEventMap>> & typeof Plugin;
 /**
  * Base class for creating Obsidian plugins with a component-based architecture.
  *
@@ -149,7 +149,7 @@ export declare abstract class PluginBase extends PluginBase_base implements Plug
  * @param plugin - The plugin to reload.
  * @returns A {@link Promise} that resolves when the plugin is reloaded.
  */
-export declare function reloadPlugin(plugin: ObsidianPlugin): Promise<void>;
+export declare function reloadPlugin(plugin: Plugin): Promise<void>;
 /**
  * Displays an error message as a notice, logs it to the console, and disables the specified plugin.
  *
@@ -157,5 +157,5 @@ export declare function reloadPlugin(plugin: ObsidianPlugin): Promise<void>;
  * @param message - The error message to display and log.
  * @returns A {@link Promise} that resolves when the plugin is disabled.
  */
-export declare function showErrorAndDisablePlugin(plugin: ObsidianPlugin, message: string): Promise<void>;
+export declare function showErrorAndDisablePlugin(plugin: Plugin, message: string): Promise<void>;
 export {};

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

@@ -21,10 +21,7 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-import {
-  Notice,
-  Plugin as ObsidianPlugin
-} from "obsidian";
+import { Plugin } from "obsidian";
 import { mixinAsyncEvents } from "../../async-events.mjs";
 import { printError } from "../../error.mjs";
 import { noopAsync } from "../../function.mjs";
@@ -37,7 +34,7 @@ import { PluginContextComponent } from "../components/plugin-context-component.m
 import { PluginNoticeComponent } from "../components/plugin-notice-component.mjs";
 import { initI18N } from "../i18n/i18n.mjs";
 import { defaultTranslationsMap } from "../i18n/locales/translations-map.mjs";
-class PluginBase extends mixinAsyncEvents()(ObsidianPlugin) {
+class PluginBase extends mixinAsyncEvents()(Plugin) {
   /**
    * Gets abort signal component.
    *
@@ -210,7 +207,8 @@ async function reloadPlugin(plugin) {
   await plugins.enablePlugin(pluginId);
 }
 async function showErrorAndDisablePlugin(plugin, message) {
-  new Notice(message);
+  const pluginNoticeComponent = new PluginNoticeComponent(plugin.manifest.name);
+  pluginNoticeComponent.showNotice(message);
   printError(new Error(message));
   await plugin.app.plugins.disablePlugin(plugin.manifest.id);
 }
@@ -219,4 +217,4 @@ export {
   reloadPlugin,
   showErrorAndDisablePlugin
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Base class for Obsidian plugins using a component-based architecture.\n *\n * PluginBase registers universal components (context, i18n, error handling, abort signal, lifecycle events, debug).\n */\n\nimport type { Component } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  Notice,\n  Plugin as ObsidianPlugin\n} from 'obsidian';\n\nimport type { TranslationsMap } from '../i18n/i18n.ts';\nimport type {\n  PluginEventMap,\n  PluginEventSource\n} from './plugin-event-source.ts';\n\nimport { mixinAsyncEvents } from '../../async-events.ts';\nimport { printError } from '../../error.ts';\nimport { noopAsync } from '../../function.ts';\nimport { ensureNonNullable } from '../../type-guards.ts';\nimport { AbortSignalComponent } from '../components/abort-signal-component.ts';\nimport { AsyncErrorHandlerComponent } from '../components/async-error-handler-component.ts';\nimport { ComponentEx } from '../components/component-ex.ts';\nimport { ConsoleDebugComponent } from '../components/console-debug-component.ts';\nimport { PluginContextComponent } from '../components/plugin-context-component.ts';\nimport { PluginNoticeComponent } from '../components/plugin-notice-component.ts';\nimport { initI18N } from '../i18n/i18n.ts';\nimport { defaultTranslationsMap } from '../i18n/locales/translations-map.ts';\n\n/**\n * Base class for creating Obsidian plugins with a component-based architecture.\n *\n * Registers universal components automatically. Subclasses add or replace components\n * via {@link removeChild} / {@link addChild}.\n */\nexport abstract class PluginBase extends mixinAsyncEvents<PluginEventMap>()(ObsidianPlugin) implements PluginEventSource {\n  /**\n   * Gets abort signal component.\n   *\n   * @returns abort signal component.\n   */\n  protected get abortSignalComponent(): AbortSignalComponent {\n    return ensureNonNullable(this._abortSignalComponent);\n  }\n\n  /**\n   * Sets abort signal component.\n   *\n   * @param value - Abort signal component.\n   */\n  protected set abortSignalComponent(value: AbortSignalComponent) {\n    this._abortSignalComponent = value;\n  }\n\n  /**\n   * Gets async error handler component.\n   *\n   * @returns async error handler component.\n   */\n  protected get asyncErrorHandlerComponent(): AsyncErrorHandlerComponent {\n    return ensureNonNullable(this._asyncErrorHandlerComponent);\n  }\n\n  /**\n   * Sets async error handler component.\n   *\n   * @param value - Async error handler component.\n   */\n  protected set asyncErrorHandlerComponent(value: AsyncErrorHandlerComponent) {\n    this._asyncErrorHandlerComponent = value;\n  }\n\n  /**\n   * Gets console debug component.\n   *\n   * @returns console debug component.\n   */\n  protected get consoleDebugComponent(): ConsoleDebugComponent {\n    return ensureNonNullable(this._consoleDebugComponent);\n  }\n\n  /**\n   * Sets console debug component.\n   *\n   * @param value - Console debug component.\n   */\n  protected set consoleDebugComponent(value: ConsoleDebugComponent) {\n    this._consoleDebugComponent = value;\n  }\n\n  /**\n   * Gets plugin context component (plugin ID, debug controller, library styles).\n   *\n   * @returns plugin context component.\n   */\n  protected get pluginContextComponent(): PluginContextComponent {\n    return ensureNonNullable(this._pluginContextComponent);\n  }\n\n  /**\n   * Sets plugin context component.\n   *\n   * @param value - Plugin context component.\n   */\n  protected set pluginContextComponent(value: PluginContextComponent) {\n    this._pluginContextComponent = value;\n  }\n\n  /**\n   * Gets plugin notice component.\n   *\n   * @returns plugin notice component.\n   */\n  protected get pluginNoticeComponent(): PluginNoticeComponent {\n    return ensureNonNullable(this._pluginNoticeComponent);\n  }\n\n  /**\n   * Sets plugin notice component.\n   *\n   * @param value - Plugin notice component.\n   */\n  protected set pluginNoticeComponent(value: PluginNoticeComponent) {\n    this._pluginNoticeComponent = value;\n  }\n\n  private _abortSignalComponent?: AbortSignalComponent;\n\n  private _asyncErrorHandlerComponent?: AsyncErrorHandlerComponent;\n\n  private _consoleDebugComponent?: ConsoleDebugComponent;\n\n  private _pluginContextComponent?: PluginContextComponent;\n\n  private _pluginNoticeComponent?: PluginNoticeComponent;\n\n  private readonly wrapperComponent = new ComponentEx();\n\n  /**\n   * Adds a child component.\n   *\n   * The child is added to an internal wrapper component so that, during {@link onloadImpl},\n   * children are queued and then loaded sequentially (children-first) when the plugin loads.\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    return this.wrapperComponent.addChild(component);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * Override in subclass if needed. Make sure to call `await super.onExternalSettingsChange()` first.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this.triggerAsync('externalSettingsChange');\n  }\n\n  /**\n   * Called when the plugin is loaded.\n   *\n   * Orchestrates loading: registers the universal components, lets the subclass wire its own\n   * components via {@link onloadImpl}, then loads all of them sequentially (children-first).\n   *\n   * Do NOT override this method. Override {@link onloadImpl} instead.\n   */\n  public override async onload(): Promise<void> {\n    await initI18N(this.createTranslationsMap());\n    this.pluginContextComponent = this.addChild(\n      new PluginContextComponent({\n        app: this.app,\n        pluginId: this.manifest.id\n      })\n    );\n    this.pluginNoticeComponent = this.addChild(new PluginNoticeComponent(this.manifest.name));\n    this.asyncErrorHandlerComponent = this.addChild(new AsyncErrorHandlerComponent(this.pluginNoticeComponent));\n    this.abortSignalComponent = this.addChild(new AbortSignalComponent(this.manifest.id));\n    this.consoleDebugComponent = this.addChild(new ConsoleDebugComponent(this.manifest.id));\n\n    await this.onloadImpl();\n\n    // Add the wrapper to the native plugin only now, after all children are queued.\n    // The plugin is already loaded, so this loads the wrapper's children sequentially (children-first).\n    // It also registers the wrapper for automatic teardown on plugin unload.\n    super.addChild(this.wrapperComponent);\n    await this.wrapperComponent.loadWithPromises();\n  }\n\n  /**\n   * Removes a child component.\n   *\n   * @typeParam TComponent - The type of component to remove.\n   * @param component - The component instance to remove.\n   * @returns The removed component.\n   */\n  public override removeChild<TComponent extends Component>(component: TComponent): TComponent {\n    return this.wrapperComponent.removeChild(component);\n  }\n\n  /**\n   * Provides the translations map used to initialize i18n during {@link onload}.\n   *\n   * Override in subclass to supply plugin-specific translations. The default returns the built-in\n   * `obsidian-dev-utils` translations.\n   *\n   * @returns The translations map.\n   */\n  protected createTranslationsMap(): TranslationsMap {\n    return defaultTranslationsMap;\n  }\n\n  /**\n   * Called during {@link onload} to wire plugin-specific child components.\n   *\n   * Override in subclass to add child components via {@link addChild}. The universal components are\n   * available here. Children are loaded sequentially in the order they are added (children-first).\n   *\n   * @returns A {@link Promise} that resolves when the subclass load logic is complete.\n   */\n  protected onloadImpl(): Promisable<void> {\n    return noopAsync();\n  }\n}\n\n/**\n * Reloads the specified plugin by disabling and then re-enabling it.\n *\n * @param plugin - The plugin to reload.\n * @returns A {@link Promise} that resolves when the plugin is reloaded.\n */\nexport async function reloadPlugin(plugin: ObsidianPlugin): Promise<void> {\n  const plugins = plugin.app.plugins;\n  const pluginId = plugin.manifest.id;\n  await plugins.disablePlugin(pluginId);\n  await plugins.enablePlugin(pluginId);\n}\n\n/**\n * Displays an error message as a notice, logs it to the console, and disables the specified plugin.\n *\n * @param plugin - The plugin to disable.\n * @param message - The error message to display and log.\n * @returns A {@link Promise} that resolves when the plugin is disabled.\n */\nexport async function showErrorAndDisablePlugin(plugin: ObsidianPlugin, message: string): Promise<void> {\n  new Notice(message);\n  printError(new Error(message));\n  await plugin.app.plugins.disablePlugin(plugin.manifest.id);\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Base class for Obsidian plugins using a component-based architecture.\n *\n * PluginBase registers universal components (context, i18n, error handling, abort signal, lifecycle events, debug).\n */\n\nimport type { Component } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { Plugin } from 'obsidian';\n\nimport type { TranslationsMap } from '../i18n/i18n.ts';\nimport type {\n  PluginEventMap,\n  PluginEventSource\n} from './plugin-event-source.ts';\n\nimport { mixinAsyncEvents } from '../../async-events.ts';\nimport { printError } from '../../error.ts';\nimport { noopAsync } from '../../function.ts';\nimport { ensureNonNullable } from '../../type-guards.ts';\nimport { AbortSignalComponent } from '../components/abort-signal-component.ts';\nimport { AsyncErrorHandlerComponent } from '../components/async-error-handler-component.ts';\nimport { ComponentEx } from '../components/component-ex.ts';\nimport { ConsoleDebugComponent } from '../components/console-debug-component.ts';\nimport { PluginContextComponent } from '../components/plugin-context-component.ts';\nimport { PluginNoticeComponent } from '../components/plugin-notice-component.ts';\nimport { initI18N } from '../i18n/i18n.ts';\nimport { defaultTranslationsMap } from '../i18n/locales/translations-map.ts';\n\n/**\n * Base class for creating Obsidian plugins with a component-based architecture.\n *\n * Registers universal components automatically. Subclasses add or replace components\n * via {@link removeChild} / {@link addChild}.\n */\nexport abstract class PluginBase extends mixinAsyncEvents<PluginEventMap>()(Plugin) implements PluginEventSource {\n  /**\n   * Gets abort signal component.\n   *\n   * @returns abort signal component.\n   */\n  protected get abortSignalComponent(): AbortSignalComponent {\n    return ensureNonNullable(this._abortSignalComponent);\n  }\n\n  /**\n   * Sets abort signal component.\n   *\n   * @param value - Abort signal component.\n   */\n  protected set abortSignalComponent(value: AbortSignalComponent) {\n    this._abortSignalComponent = value;\n  }\n\n  /**\n   * Gets async error handler component.\n   *\n   * @returns async error handler component.\n   */\n  protected get asyncErrorHandlerComponent(): AsyncErrorHandlerComponent {\n    return ensureNonNullable(this._asyncErrorHandlerComponent);\n  }\n\n  /**\n   * Sets async error handler component.\n   *\n   * @param value - Async error handler component.\n   */\n  protected set asyncErrorHandlerComponent(value: AsyncErrorHandlerComponent) {\n    this._asyncErrorHandlerComponent = value;\n  }\n\n  /**\n   * Gets console debug component.\n   *\n   * @returns console debug component.\n   */\n  protected get consoleDebugComponent(): ConsoleDebugComponent {\n    return ensureNonNullable(this._consoleDebugComponent);\n  }\n\n  /**\n   * Sets console debug component.\n   *\n   * @param value - Console debug component.\n   */\n  protected set consoleDebugComponent(value: ConsoleDebugComponent) {\n    this._consoleDebugComponent = value;\n  }\n\n  /**\n   * Gets plugin context component (plugin ID, debug controller, library styles).\n   *\n   * @returns plugin context component.\n   */\n  protected get pluginContextComponent(): PluginContextComponent {\n    return ensureNonNullable(this._pluginContextComponent);\n  }\n\n  /**\n   * Sets plugin context component.\n   *\n   * @param value - Plugin context component.\n   */\n  protected set pluginContextComponent(value: PluginContextComponent) {\n    this._pluginContextComponent = value;\n  }\n\n  /**\n   * Gets plugin notice component.\n   *\n   * @returns plugin notice component.\n   */\n  protected get pluginNoticeComponent(): PluginNoticeComponent {\n    return ensureNonNullable(this._pluginNoticeComponent);\n  }\n\n  /**\n   * Sets plugin notice component.\n   *\n   * @param value - Plugin notice component.\n   */\n  protected set pluginNoticeComponent(value: PluginNoticeComponent) {\n    this._pluginNoticeComponent = value;\n  }\n\n  private _abortSignalComponent?: AbortSignalComponent;\n\n  private _asyncErrorHandlerComponent?: AsyncErrorHandlerComponent;\n\n  private _consoleDebugComponent?: ConsoleDebugComponent;\n\n  private _pluginContextComponent?: PluginContextComponent;\n\n  private _pluginNoticeComponent?: PluginNoticeComponent;\n\n  private readonly wrapperComponent = new ComponentEx();\n\n  /**\n   * Adds a child component.\n   *\n   * The child is added to an internal wrapper component so that, during {@link onloadImpl},\n   * children are queued and then loaded sequentially (children-first) when the plugin loads.\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    return this.wrapperComponent.addChild(component);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * Override in subclass if needed. Make sure to call `await super.onExternalSettingsChange()` first.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this.triggerAsync('externalSettingsChange');\n  }\n\n  /**\n   * Called when the plugin is loaded.\n   *\n   * Orchestrates loading: registers the universal components, lets the subclass wire its own\n   * components via {@link onloadImpl}, then loads all of them sequentially (children-first).\n   *\n   * Do NOT override this method. Override {@link onloadImpl} instead.\n   */\n  public override async onload(): Promise<void> {\n    await initI18N(this.createTranslationsMap());\n    this.pluginContextComponent = this.addChild(\n      new PluginContextComponent({\n        app: this.app,\n        pluginId: this.manifest.id\n      })\n    );\n    this.pluginNoticeComponent = this.addChild(new PluginNoticeComponent(this.manifest.name));\n    this.asyncErrorHandlerComponent = this.addChild(new AsyncErrorHandlerComponent(this.pluginNoticeComponent));\n    this.abortSignalComponent = this.addChild(new AbortSignalComponent(this.manifest.id));\n    this.consoleDebugComponent = this.addChild(new ConsoleDebugComponent(this.manifest.id));\n\n    await this.onloadImpl();\n\n    // Add the wrapper to the native plugin only now, after all children are queued.\n    // The plugin is already loaded, so this loads the wrapper's children sequentially (children-first).\n    // It also registers the wrapper for automatic teardown on plugin unload.\n    super.addChild(this.wrapperComponent);\n    await this.wrapperComponent.loadWithPromises();\n  }\n\n  /**\n   * Removes a child component.\n   *\n   * @typeParam TComponent - The type of component to remove.\n   * @param component - The component instance to remove.\n   * @returns The removed component.\n   */\n  public override removeChild<TComponent extends Component>(component: TComponent): TComponent {\n    return this.wrapperComponent.removeChild(component);\n  }\n\n  /**\n   * Provides the translations map used to initialize i18n during {@link onload}.\n   *\n   * Override in subclass to supply plugin-specific translations. The default returns the built-in\n   * `obsidian-dev-utils` translations.\n   *\n   * @returns The translations map.\n   */\n  protected createTranslationsMap(): TranslationsMap {\n    return defaultTranslationsMap;\n  }\n\n  /**\n   * Called during {@link onload} to wire plugin-specific child components.\n   *\n   * Override in subclass to add child components via {@link addChild}. The universal components are\n   * available here. Children are loaded sequentially in the order they are added (children-first).\n   *\n   * @returns A {@link Promise} that resolves when the subclass load logic is complete.\n   */\n  protected onloadImpl(): Promisable<void> {\n    return noopAsync();\n  }\n}\n\n/**\n * Reloads the specified plugin by disabling and then re-enabling it.\n *\n * @param plugin - The plugin to reload.\n * @returns A {@link Promise} that resolves when the plugin is reloaded.\n */\nexport async function reloadPlugin(plugin: Plugin): Promise<void> {\n  const plugins = plugin.app.plugins;\n  const pluginId = plugin.manifest.id;\n  await plugins.disablePlugin(pluginId);\n  await plugins.enablePlugin(pluginId);\n}\n\n/**\n * Displays an error message as a notice, logs it to the console, and disables the specified plugin.\n *\n * @param plugin - The plugin to disable.\n * @param message - The error message to display and log.\n * @returns A {@link Promise} that resolves when the plugin is disabled.\n */\nexport async function showErrorAndDisablePlugin(plugin: Plugin, message: string): Promise<void> {\n  const pluginNoticeComponent = new PluginNoticeComponent(plugin.manifest.name);\n  pluginNoticeComponent.showNotice(message);\n  printError(new Error(message));\n  await plugin.app.plugins.disablePlugin(plugin.manifest.id);\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -35,6 +35,7 @@ import {
   noopAsync
 } from "../function.mjs";
 import { getObsidianDevUtilsState } from "../obsidian-dev-utils-state.mjs";
+import { strictProxy } from "../strict-proxy.mjs";
 import { runWithTimeoutNotice } from "./async-with-notice.mjs";
 import { t } from "./i18n/i18n.mjs";
 import { invokeAsyncAndLog } from "./logger.mjs";
@@ -80,14 +81,15 @@ async function processNextQueueItem() {
     () => runWithTimeoutNotice({
       context: { queuedFn: item.operationFn },
       async operationFn(abortSignal) {
-        await invokeAsyncAndLog(
-          item.operationName || processNextQueueItem.name,
-          item.operationFn,
-          abortSignalAny(abortSignal, item.abortSignal),
-          item.stackTrace
-        );
+        await invokeAsyncAndLog({
+          abortSignal: abortSignalAny(abortSignal, item.abortSignal),
+          fn: item.operationFn,
+          stackTrace: item.stackTrace,
+          title: item.operationName || processNextQueueItem.name
+        });
       },
       operationName: item.operationName,
+      pluginNoticeComponent: strictProxy({}),
       shouldShowTimeoutNotice: item.shouldShowTimeoutNotice,
       stackTrace: item.stackTrace,
       timeoutInMilliseconds: item.timeoutInMilliseconds
@@ -100,4 +102,4 @@ export {
   addToQueueAndWait,
   flushQueue
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/queue.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for enqueuing and processing functions in Obsidian.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport type { ValueWrapper } from '../value-wrapper.ts';\n\nimport {\n  abortSignalAny,\n  abortSignalNever\n} from '../abort-controller.ts';\nimport {\n  addErrorHandler,\n  invokeAsyncSafely\n} from '../async.ts';\nimport { getStackTrace } from '../error.ts';\nimport {\n  noop,\n  noopAsync\n} from '../function.ts';\nimport { getObsidianDevUtilsState } from '../obsidian-dev-utils-state.ts';\nimport { runWithTimeoutNotice } from './async-with-notice.ts';\nimport { t } from './i18n/i18n.ts';\nimport { invokeAsyncAndLog } from './logger.ts';\n\n/**\n * Options for the {@link addToQueueAndWait} function.\n */\nexport interface AddToQueueAndWaitParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The function to add.\n   */\n  operationFn(this: void, abortSignal: AbortSignal): Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Options for the {@link addToQueue} function.\n */\nexport interface AddToQueueParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The function to add.\n   */\n  operationFn(this: void, abortSignal: AbortSignal): Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\ninterface Queue {\n  items: QueueItem[];\n  promise: Promise<void>;\n}\n\ninterface QueueItem {\n  abortSignal: AbortSignal;\n  operationFn(this: void, abortSignal: AbortSignal): Promisable<void>;\n  operationName: string;\n  shouldShowTimeoutNotice: boolean;\n  stackTrace: string;\n  timeoutInMilliseconds: number;\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes.\n *\n * @param params - The parameters for the function.\n */\nexport function addToQueue(params: AddToQueueParams): void {\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  invokeAsyncSafely(() => addToQueueAndWait(params), stackTrace);\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes and returns a {@link Promise} that resolves when the function completes.\n *\n * @param params - The parameters for the function.\n */\nexport async function addToQueueAndWait(params: AddToQueueAndWaitParams): Promise<void> {\n  const abortSignal = params.abortSignal ?? abortSignalNever();\n  abortSignal.throwIfAborted();\n\n  const DEFAULT_TIMEOUT_IN_MILLISECONDS = 60000;\n  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const operationName = params.operationName ?? '';\n  const queue = getQueue().value;\n  queue.items.push({\n    abortSignal,\n    operationFn: params.operationFn,\n    operationName,\n    shouldShowTimeoutNotice: params.shouldShowTimeoutNotice ?? true,\n    stackTrace,\n    timeoutInMilliseconds\n  });\n  queue.promise = queue.promise.then(() => processNextQueueItem());\n  await queue.promise;\n}\n\n/**\n * Flushes the queue;\n */\nexport async function flushQueue(): Promise<void> {\n  await addToQueueAndWait({\n    operationFn: noop,\n    operationName: t(($) => $.obsidianDevUtils.queue.flushQueue)\n  });\n}\n\nfunction getQueue(): ValueWrapper<Queue> {\n  return getObsidianDevUtilsState('queue', { items: [], promise: noopAsync() });\n}\n\nasync function processNextQueueItem(): Promise<void> {\n  const queue = getQueue().value;\n  const item = queue.items[0];\n  /* v8 ignore start -- Defensive check; processNextQueueItem is only called after an item is pushed. */\n  if (!item) {\n    return;\n  }\n  /* v8 ignore stop */\n\n  await addErrorHandler(() =>\n    runWithTimeoutNotice({\n      context: { queuedFn: item.operationFn },\n      async operationFn(abortSignal: AbortSignal): Promise<void> {\n        await invokeAsyncAndLog(\n          item.operationName || processNextQueueItem.name,\n          item.operationFn,\n          abortSignalAny(abortSignal, item.abortSignal),\n          item.stackTrace\n        );\n      },\n      operationName: item.operationName,\n      shouldShowTimeoutNotice: item.shouldShowTimeoutNotice,\n      stackTrace: item.stackTrace,\n      timeoutInMilliseconds: item.timeoutInMilliseconds\n    })\n  );\n  queue.items.shift();\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAUA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gCAAgC;AACzC,SAAS,4BAA4B;AACrC,SAAS,SAAS;AAClB,SAAS,yBAAyB;AA2F3B,SAAS,WAAW,QAAgC;AACzD,QAAM,aAAa,OAAO,cAAc,cAAc,CAAC;AACvD,oBAAkB,MAAM,kBAAkB,MAAM,GAAG,UAAU;AAC/D;AAOA,eAAsB,kBAAkB,QAAgD;AACtF,QAAM,cAAc,OAAO,eAAe,iBAAiB;AAC3D,cAAY,eAAe;AAE3B,QAAM,kCAAkC;AACxC,QAAM,wBAAwB,OAAO,yBAAyB;AAC9D,QAAM,aAAa,OAAO,cAAc,cAAc,CAAC;AACvD,QAAM,gBAAgB,OAAO,iBAAiB;AAC9C,QAAM,QAAQ,SAAS,EAAE;AACzB,QAAM,MAAM,KAAK;AAAA,IACf;AAAA,IACA,aAAa,OAAO;AAAA,IACpB;AAAA,IACA,yBAAyB,OAAO,2BAA2B;AAAA,IAC3D;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,UAAU,MAAM,QAAQ,KAAK,MAAM,qBAAqB,CAAC;AAC/D,QAAM,MAAM;AACd;AAKA,eAAsB,aAA4B;AAChD,QAAM,kBAAkB;AAAA,IACtB,aAAa;AAAA,IACb,eAAe,EAAE,CAAC,MAAM,EAAE,iBAAiB,MAAM,UAAU;AAAA,EAC7D,CAAC;AACH;AAEA,SAAS,WAAgC;AACvC,SAAO,yBAAyB,SAAS,EAAE,OAAO,CAAC,GAAG,SAAS,UAAU,EAAE,CAAC;AAC9E;AAEA,eAAe,uBAAsC;AACnD,QAAM,QAAQ,SAAS,EAAE;AACzB,QAAM,OAAO,MAAM,MAAM,CAAC;AAE1B,MAAI,CAAC,MAAM;AACT;AAAA,EACF;AAGA,QAAM;AAAA,IAAgB,MACpB,qBAAqB;AAAA,MACnB,SAAS,EAAE,UAAU,KAAK,YAAY;AAAA,MACtC,MAAM,YAAY,aAAyC;AACzD,cAAM;AAAA,UACJ,KAAK,iBAAiB,qBAAqB;AAAA,UAC3C,KAAK;AAAA,UACL,eAAe,aAAa,KAAK,WAAW;AAAA,UAC5C,KAAK;AAAA,QACP;AAAA,MACF;AAAA,MACA,eAAe,KAAK;AAAA,MACpB,yBAAyB,KAAK;AAAA,MAC9B,YAAY,KAAK;AAAA,MACjB,uBAAuB,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AACA,QAAM,MAAM,MAAM;AACpB;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/queue.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for enqueuing and processing functions in Obsidian.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport type { ValueWrapper } from '../value-wrapper.ts';\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport {\n  abortSignalAny,\n  abortSignalNever\n} from '../abort-controller.ts';\nimport {\n  addErrorHandler,\n  invokeAsyncSafely\n} from '../async.ts';\nimport { getStackTrace } from '../error.ts';\nimport {\n  noop,\n  noopAsync\n} from '../function.ts';\nimport { getObsidianDevUtilsState } from '../obsidian-dev-utils-state.ts';\nimport { strictProxy } from '../strict-proxy.ts';\nimport { runWithTimeoutNotice } from './async-with-notice.ts';\nimport { t } from './i18n/i18n.ts';\nimport { invokeAsyncAndLog } from './logger.ts';\n\n/**\n * Options for the {@link addToQueueAndWait} function.\n */\nexport interface AddToQueueAndWaitParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The function to add.\n   */\n  operationFn(this: void, abortSignal: AbortSignal): Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Options for the {@link addToQueue} function.\n */\nexport interface AddToQueueParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The function to add.\n   */\n  operationFn(this: void, abortSignal: AbortSignal): Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\ninterface Queue {\n  items: QueueItem[];\n  promise: Promise<void>;\n}\n\ninterface QueueItem {\n  abortSignal: AbortSignal;\n  operationFn(this: void, abortSignal: AbortSignal): Promisable<void>;\n  operationName: string;\n  shouldShowTimeoutNotice: boolean;\n  stackTrace: string;\n  timeoutInMilliseconds: number;\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes.\n *\n * @param params - The parameters for the function.\n */\nexport function addToQueue(params: AddToQueueParams): void {\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  invokeAsyncSafely(() => addToQueueAndWait(params), stackTrace);\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes and returns a {@link Promise} that resolves when the function completes.\n *\n * @param params - The parameters for the function.\n */\nexport async function addToQueueAndWait(params: AddToQueueAndWaitParams): Promise<void> {\n  const abortSignal = params.abortSignal ?? abortSignalNever();\n  abortSignal.throwIfAborted();\n\n  const DEFAULT_TIMEOUT_IN_MILLISECONDS = 60000;\n  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const operationName = params.operationName ?? '';\n  const queue = getQueue().value;\n  queue.items.push({\n    abortSignal,\n    operationFn: params.operationFn,\n    operationName,\n    shouldShowTimeoutNotice: params.shouldShowTimeoutNotice ?? true,\n    stackTrace,\n    timeoutInMilliseconds\n  });\n  queue.promise = queue.promise.then(() => processNextQueueItem());\n  await queue.promise;\n}\n\n/**\n * Flushes the queue;\n */\nexport async function flushQueue(): Promise<void> {\n  await addToQueueAndWait({\n    operationFn: noop,\n    operationName: t(($) => $.obsidianDevUtils.queue.flushQueue)\n  });\n}\n\nfunction getQueue(): ValueWrapper<Queue> {\n  return getObsidianDevUtilsState('queue', { items: [], promise: noopAsync() });\n}\n\nasync function processNextQueueItem(): Promise<void> {\n  const queue = getQueue().value;\n  const item = queue.items[0];\n  /* v8 ignore start -- Defensive check; processNextQueueItem is only called after an item is pushed. */\n  if (!item) {\n    return;\n  }\n  /* v8 ignore stop */\n\n  await addErrorHandler(() =>\n    runWithTimeoutNotice({\n      context: { queuedFn: item.operationFn },\n      async operationFn(abortSignal: AbortSignal): Promise<void> {\n        await invokeAsyncAndLog({\n          abortSignal: abortSignalAny(abortSignal, item.abortSignal),\n          fn: item.operationFn,\n          stackTrace: item.stackTrace,\n          title: item.operationName || processNextQueueItem.name\n        });\n      },\n      operationName: item.operationName,\n      pluginNoticeComponent: strictProxy<PluginNoticeComponent>({}),\n      shouldShowTimeoutNotice: item.shouldShowTimeoutNotice,\n      stackTrace: item.stackTrace,\n      timeoutInMilliseconds: item.timeoutInMilliseconds\n    })\n  );\n  queue.items.shift();\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAWA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gCAAgC;AACzC,SAAS,mBAAmB;AAC5B,SAAS,4BAA4B;AACrC,SAAS,SAAS;AAClB,SAAS,yBAAyB;AA2F3B,SAAS,WAAW,QAAgC;AACzD,QAAM,aAAa,OAAO,cAAc,cAAc,CAAC;AACvD,oBAAkB,MAAM,kBAAkB,MAAM,GAAG,UAAU;AAC/D;AAOA,eAAsB,kBAAkB,QAAgD;AACtF,QAAM,cAAc,OAAO,eAAe,iBAAiB;AAC3D,cAAY,eAAe;AAE3B,QAAM,kCAAkC;AACxC,QAAM,wBAAwB,OAAO,yBAAyB;AAC9D,QAAM,aAAa,OAAO,cAAc,cAAc,CAAC;AACvD,QAAM,gBAAgB,OAAO,iBAAiB;AAC9C,QAAM,QAAQ,SAAS,EAAE;AACzB,QAAM,MAAM,KAAK;AAAA,IACf;AAAA,IACA,aAAa,OAAO;AAAA,IACpB;AAAA,IACA,yBAAyB,OAAO,2BAA2B;AAAA,IAC3D;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,UAAU,MAAM,QAAQ,KAAK,MAAM,qBAAqB,CAAC;AAC/D,QAAM,MAAM;AACd;AAKA,eAAsB,aAA4B;AAChD,QAAM,kBAAkB;AAAA,IACtB,aAAa;AAAA,IACb,eAAe,EAAE,CAAC,MAAM,EAAE,iBAAiB,MAAM,UAAU;AAAA,EAC7D,CAAC;AACH;AAEA,SAAS,WAAgC;AACvC,SAAO,yBAAyB,SAAS,EAAE,OAAO,CAAC,GAAG,SAAS,UAAU,EAAE,CAAC;AAC9E;AAEA,eAAe,uBAAsC;AACnD,QAAM,QAAQ,SAAS,EAAE;AACzB,QAAM,OAAO,MAAM,MAAM,CAAC;AAE1B,MAAI,CAAC,MAAM;AACT;AAAA,EACF;AAGA,QAAM;AAAA,IAAgB,MACpB,qBAAqB;AAAA,MACnB,SAAS,EAAE,UAAU,KAAK,YAAY;AAAA,MACtC,MAAM,YAAY,aAAyC;AACzD,cAAM,kBAAkB;AAAA,UACtB,aAAa,eAAe,aAAa,KAAK,WAAW;AAAA,UACzD,IAAI,KAAK;AAAA,UACT,YAAY,KAAK;AAAA,UACjB,OAAO,KAAK,iBAAiB,qBAAqB;AAAA,QACpD,CAAC;AAAA,MACH;AAAA,MACA,eAAe,KAAK;AAAA,MACpB,uBAAuB,YAAmC,CAAC,CAAC;AAAA,MAC5D,yBAAyB,KAAK;AAAA,MAC9B,YAAY,KAAK;AAAA,MACjB,uBAAuB,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AACA,QAAM,MAAM,MAAM;AACpB;",
  "names": []
}


package/dist/lib/esm/obsidian/resource-url.d.mts

@@ -5,12 +5,27 @@
  * This module provides utility functions for working with resource URLs in Obsidian.
  */
 import type { App } from 'obsidian';
+/**
+ * Parameters for {@link relativePathToResourceUrl}.
+ */
+export interface RelativePathToResourceUrlParams {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The path of the note.
+     */
+    readonly notePath: string;
+    /**
+     * The relative path to the resource.
+     */
+    readonly relativePath: string;
+}
 /**
  * Converts a relative path to a resource URL.
  *
- * @param app - The Obsidian application instance.
- * @param relativePath - The relative path to the resource.
- * @param notePath - The path of the note.
+ * @param params - The parameters for the conversion.
  * @returns The resource URL.
  */
-export declare function relativePathToResourceUrl(app: App, relativePath: string, notePath: string): string;
+export declare function relativePathToResourceUrl(params: RelativePathToResourceUrlParams): string;

package/dist/lib/esm/obsidian/resource-url.mjs

@@ -24,7 +24,12 @@ if you want to view the source, please visit the github repository of this plugi
 import { getDataAdapterEx } from "@obsidian-typings/obsidian-public-latest/implementations";
 import { Platform } from "obsidian";
 import { toPosixPath } from "../path.mjs";
-function relativePathToResourceUrl(app, relativePath, notePath) {
+function relativePathToResourceUrl(params) {
+  const {
+    app,
+    notePath,
+    relativePath
+  } = params;
   const noteFullPath = toPosixPath(getDataAdapterEx(app).getFullRealPath(notePath));
   const noteUrl = `${Platform.resourcePathPrefix}${noteFullPath}`;
   const relativeUrl = new URL(relativePath, noteUrl);
@@ -33,4 +38,4 @@ function relativePathToResourceUrl(app, relativePath, notePath) {
 export {
   relativePathToResourceUrl
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3Jlc291cmNlLXVybC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIHV0aWxpdHkgZnVuY3Rpb25zIGZvciB3b3JraW5nIHdpdGggcmVzb3VyY2UgVVJMcyBpbiBPYnNpZGlhbi5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IEFwcCB9IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHsgZ2V0RGF0YUFkYXB0ZXJFeCB9IGZyb20gJ0BvYnNpZGlhbi10eXBpbmdzL29ic2lkaWFuLXB1YmxpYy1sYXRlc3QvaW1wbGVtZW50YXRpb25zJztcbmltcG9ydCB7IFBsYXRmb3JtIH0gZnJvbSAnb2JzaWRpYW4nO1xuXG5pbXBvcnQgeyB0b1Bvc2l4UGF0aCB9IGZyb20gJy4uL3BhdGgudHMnO1xuXG4vKipcbiAqIENvbnZlcnRzIGEgcmVsYXRpdmUgcGF0aCB0byBhIHJlc291cmNlIFVSTC5cbiAqXG4gKiBAcGFyYW0gYXBwIC0gVGhlIE9ic2lkaWFuIGFwcGxpY2F0aW9uIGluc3RhbmNlLlxuICogQHBhcmFtIHJlbGF0aXZlUGF0aCAtIFRoZSByZWxhdGl2ZSBwYXRoIHRvIHRoZSByZXNvdXJjZS5cbiAqIEBwYXJhbSBub3RlUGF0aCAtIFRoZSBwYXRoIG9mIHRoZSBub3RlLlxuICogQHJldHVybnMgVGhlIHJlc291cmNlIFVSTC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlbGF0aXZlUGF0aFRvUmVzb3VyY2VVcmwoYXBwOiBBcHAsIHJlbGF0aXZlUGF0aDogc3RyaW5nLCBub3RlUGF0aDogc3RyaW5nKTogc3RyaW5nIHtcbiAgY29uc3Qgbm90ZUZ1bGxQYXRoID0gdG9Qb3NpeFBhdGgoZ2V0RGF0YUFkYXB0ZXJFeChhcHApLmdldEZ1bGxSZWFsUGF0aChub3RlUGF0aCkpO1xuICBjb25zdCBub3RlVXJsID0gYCR7UGxhdGZvcm0ucmVzb3VyY2VQYXRoUHJlZml4fSR7bm90ZUZ1bGxQYXRofWA7XG4gIGNvbnN0IHJlbGF0aXZlVXJsID0gbmV3IFVSTChyZWxhdGl2ZVBhdGgsIG5vdGVVcmwpO1xuICByZXR1cm4gU3RyaW5nKHJlbGF0aXZlVXJsKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBUUEsU0FBUyx3QkFBd0I7QUFDakMsU0FBUyxnQkFBZ0I7QUFFekIsU0FBUyxtQkFBbUI7QUFVckIsU0FBUywwQkFBMEIsS0FBVSxjQUFzQixVQUEwQjtBQUNsRyxRQUFNLGVBQWUsWUFBWSxpQkFBaUIsR0FBRyxFQUFFLGdCQUFnQixRQUFRLENBQUM7QUFDaEYsUUFBTSxVQUFVLEdBQUcsU0FBUyxrQkFBa0IsR0FBRyxZQUFZO0FBQzdELFFBQU0sY0FBYyxJQUFJLElBQUksY0FBYyxPQUFPO0FBQ2pELFNBQU8sT0FBTyxXQUFXO0FBQzNCOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,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