obsidian-dev-utils 98.0.0 → 100.0.0

package/dist/lib/cjs/obsidian/components/plugin-settings-component.cjs

@@ -204,8 +204,10 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
   pluginSettingsClass;
   asyncEvents = new import_async_events.AsyncEvents();
   currentState;
+  isLoadedFromFile = false;
   lastSavedState;
   legacySettingsConverters = [];
+  loadedFromFileResolvers = [];
   propertyNames;
   validators = /* @__PURE__ */ new Map();
   /**
@@ -303,6 +305,7 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
         await this.saveToFileImpl();
       }
     } finally {
+      this.markLoadedFromFile();
       await this.asyncEvents.triggerAsync("loadSettings", this.currentState, isInitialLoad);
     }
   }
@@ -472,6 +475,31 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
     }
     return result;
   }
+  /**
+   * Waits until the settings have been read from `data.json` at least once.
+   *
+   * Anything that reads a setting from outside this component has to wait for this, because until the first
+   * {@link loadFromFile} completes {@link settings} still holds the DEFAULTS — reading it earlier answers
+   * with a default rather than with what the user actually stored. That window is easy to miss, since it is
+   * empty on a cold start (the workspace layout is not ready yet, so nothing has run) but wide open on a
+   * runtime enable from the Community Plugins tab or a re-enable after an update, where a layout-ready
+   * handler fires immediately while this component's own async load is still in flight.
+   *
+   * Resolves immediately once the settings have loaded, so a caller that arrives late is not stranded
+   * waiting for an event that has already been raised. Later reloads (an external `data.json` change) do
+   * not reset it — the question it answers is whether the settings have EVER been read, not whether the
+   * most recent read has finished.
+   *
+   * @returns A {@link Promise} that resolves once the settings have been loaded from the file.
+   */
+  whenLoadedFromFile() {
+    if (this.isLoadedFromFile) {
+      return (0, import_function.noopAsync)();
+    }
+    return new Promise((resolve) => {
+      this.loadedFromFileResolvers.push(resolve);
+    });
+  }
   /**
    * Gets the transformer.
    *
@@ -574,6 +602,13 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
     }
     return this.propertyNames.includes(property);
   }
+  markLoadedFromFile() {
+    this.isLoadedFromFile = true;
+    const resolvers = this.loadedFromFileResolvers.splice(0);
+    for (const resolve of resolvers) {
+      resolve();
+    }
+  }
   async rawRecordToSettings(rawRecord) {
     rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);
     await this.onLoadRecord(rawRecord);
@@ -625,4 +660,4 @@ class PluginSettingsComponentBase extends import_component_ex.ComponentEx {
 0 && (module.exports = {
   PluginSettingsComponentBase
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-settings-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that manages plugin settings: data, persistence, validation, and events.\n *\n * This is the single public-facing settings API for plugin authors.\n * All settings logic (load, save, validate, transform, clone) is handled directly\n * by this component \u2014 no separate manager class is needed.\n */\n\nimport type {\n  Constructor,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type {\n  AsyncEventRef,\n  AsyncEventSource\n} from '../../async-events.ts';\nimport type { Transformer } from '../../transformers/transformer.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../type.ts';\nimport type { DataHandler } from '../data-handler.ts';\nimport type { PluginEventSource } from '../plugin/plugin-event-source.ts';\n\nimport { AsyncEvents } from '../../async-events.ts';\nimport { getLibDebugger } from '../../debug.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport {\n  castTo,\n  getAllKeys,\n  isDeepEqual\n} from '../../object-utils.ts';\nimport { DateTransformer } from '../../transformers/date-transformer.ts';\nimport { DurationTransformer } from '../../transformers/duration-transformer.ts';\nimport { GroupTransformer } from '../../transformers/group-transformer.ts';\nimport { MapTransformer } from '../../transformers/map-transformer.ts';\nimport { SetTransformer } from '../../transformers/set-transformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../transformers/skip-private-property-transformer.ts';\nimport { TwoWayMapTransformer } from '../../transformers/two-way-map-transformer.ts';\nimport { ValueWrapper } from '../../value-wrapper.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer(),\n  new MapTransformer(),\n  new SetTransformer(),\n  new TwoWayMapTransformer()\n]);\n\n/**\n * Constructor parameters for {@link PluginSettingsComponentBase}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseConstructorParams<PluginSettings> {\n  /**\n   * The data handler for the plugin.\n   */\n  readonly dataHandler: DataHandler;\n\n  /**\n   * The plugin events.\n   */\n  readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class.\n   */\n  readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.onSaveSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseOnSaveSettingsParams<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 * A snapshot of plugin settings state, including raw input values, effective (validated) values,\n * and per-property validation messages.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsState<PluginSettings extends object> {\n  /**\n   * The effective settings values used by the plugin. Invalid properties are replaced with defaults.\n   */\n  effectiveValues: PluginSettings;\n\n  /**\n   * The raw input values as entered by the user. May contain invalid values.\n   */\n  inputValues: PluginSettings;\n\n  /**\n   * Per-property validation messages. Empty string means valid.\n   */\n  validationMessages: Record<StringKeys<PluginSettings>, string>;\n}\n\n/**\n * Readonly version of {@link PluginSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettings<PluginSettings extends object> = ReadonlyDeep<PluginSettings>;\n\n/**\n * Readonly version of {@link PluginSettingsState} for use in event callbacks and public getters.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettingsState<PluginSettings extends object> = ReadonlyDeep<PluginSettingsState<PluginSettings>>;\n\n/**\n * A validator function for a settings property.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam PropertyName - The property name.\n */\nexport type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<string>>;\n\ninterface PluginSettingsComponentBaseEventMap<PluginSettings extends object> {\n  loadSettings: [\n    loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    isInitialLoad: boolean\n  ];\n  saveSettings: [\n    newState: ReadonlyPluginSettingsState<PluginSettings>,\n    oldState: ReadonlyPluginSettingsState<PluginSettings>,\n    context: unknown\n  ];\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.setPropertyImpl}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\ninterface PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings extends object> {\n  /**\n   * The name of the property to set.\n   */\n  readonly propertyName: PropertyNames<PluginSettings>;\n\n  /**\n   * The validation message. Empty or unset means valid.\n   */\n  readonly validationMessage?: string | undefined;\n\n  /**\n   * The value to set.\n   */\n  readonly value: PropertyValues<PluginSettings>;\n}\n\ntype PropertyNames<PluginSettings extends object> = StringKeys<PluginSettings>;\n\ntype PropertyValues<PluginSettings extends object> = PluginSettings[PropertyNames<PluginSettings>];\n\ntype ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;\n\n/**\n * Base class for plugin settings components.\n *\n * Manages settings data, persistence, validation, and events.\n * Plugin authors extend this class and implement {@link createDefaultSettings}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\n// eslint-disable-next-line obsidian-dev-utils/require-component-suffix -- Non-abstract base class; consumers extend it.\nexport class PluginSettingsComponentBase<PluginSettings extends object> extends ComponentEx implements AsyncEventSource<PluginSettingsComponentBaseEventMap<PluginSettings>> {\n  /**\n   * Gets the readonly default settings.\n   *\n   * @returns The default settings (as a readonly object).\n   */\n  public readonly defaultSettings: ReadonlyDeep<PluginSettings>;\n\n  /**\n   * Gets the readonly effective settings (validated, with defaults substituted for invalid values).\n   *\n   * @returns The readonly effective settings.\n   */\n  public get settings(): ReadonlyDeep<PluginSettings> {\n    return this.settingsState.effectiveValues;\n  }\n\n  /**\n   * Gets the current settings state snapshot.\n   *\n   * @returns The current settings state.\n   */\n  public get settingsState(): ReadonlyPluginSettingsState<PluginSettings> {\n    return this.currentState as ReadonlyPluginSettingsState<PluginSettings>;\n  }\n\n  /**\n   * The data handler used to load and save the plugin settings.\n   */\n  protected readonly dataHandler: DataHandler;\n  /**\n   * The plugin event source the component listens to for external settings changes.\n   */\n  protected readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class used to construct settings instances.\n   */\n  protected readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n  private readonly asyncEvents = new AsyncEvents<PluginSettingsComponentBaseEventMap<PluginSettings>>();\n  private currentState: PluginSettingsState<PluginSettings>;\n\n  private lastSavedState: PluginSettingsState<PluginSettings>;\n\n  private readonly legacySettingsConverters: ((record: GenericObject) => void)[] = [];\n  private readonly propertyNames: PropertyNames<PluginSettings>[];\n\n  private readonly validators = new Map<PropertyNames<PluginSettings>, SettingsValidator<PluginSettings>>();\n\n  /**\n   * Creates a new plugin settings component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSettingsComponentBaseConstructorParams<PluginSettings>) {\n    super();\n    this.dataHandler = params.dataHandler;\n    this.pluginSettingsClass = params.pluginSettingsClass;\n    this.pluginEventSource = params.pluginEventSource;\n\n    this.defaultSettings = new this.pluginSettingsClass() as ReadonlyDeep<PluginSettings>;\n    this.currentState = this.createDefaultState();\n    this.lastSavedState = this.createDefaultState();\n    this.propertyNames = getAllKeys(this.currentState.inputValues);\n    this.registerValidators();\n    this.registerLegacySettingsConverters();\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param settingsEditor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(settingsEditor: (settings: PluginSettings) => Promisable<void>, context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    await this.edit(settingsEditor);\n    await this.saveToFile(context);\n  }\n\n  /**\n   * Ensures the settings are safe.\n   *\n   * It runs validation for each property and sets the default value if the validation fails.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves when the settings are safe.\n   */\n  public async ensureSafe(settings: PluginSettings): Promise<void> {\n    const validationResult = await this.validate(settings);\n    const defaults = this.defaultSettings as PluginSettings;\n    for (const propertyName of this.propertyNames) {\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- This tests whether a validation message is non-empty, not whether the key exists.\n      if (validationResult[propertyName]) {\n        settings[propertyName] = defaults[propertyName];\n      }\n    }\n  }\n\n  /**\n   * Gets a safe copy of the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the safe copy of the settings.\n   */\n  public async getSafeCopy(settings: PluginSettings): Promise<PluginSettings> {\n    const safeSettings = await this.cloneSettings(settings);\n    await this.ensureSafe(safeSettings);\n    return safeSettings;\n  }\n\n  /**\n   * Loads the plugin settings from the file.\n   *\n   * @param isInitialLoad - Whether the settings are being loaded for the first time.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    this.ensureLoaded();\n    const data = await this.dataHandler.loadData();\n    this.lastSavedState = this.createDefaultState();\n    this.currentState = this.createDefaultState();\n\n    try {\n      if (data === undefined || data === null) {\n        return;\n      }\n\n      if (typeof data !== 'object') {\n        console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);\n        return;\n      }\n\n      const rawRecord = data as GenericObject;\n      const parsedSettings = await this.rawRecordToSettings(rawRecord);\n      const validationResult = await this.validate(parsedSettings);\n\n      for (const propertyName of this.propertyNames) {\n        this.setPropertyImpl({\n          propertyName,\n          validationMessage: validationResult[propertyName],\n          value: parsedSettings[propertyName]\n        });\n      }\n\n      this.lastSavedState = await this.cloneState(this.currentState);\n\n      // A component that knows no property names cannot normalize anything: `settingsToRawRecord()` can\n      // Only ever return `{}`, so the save below would not rewrite `data.json` -- it would empty it.\n      // `PluginBase` adds a placeholder `PluginSettingsComponentBase<object>` before `onloadImpl()` swaps\n      // In the plugin's own component, and that placeholder is exactly this case: it read every real\n      // Setting, kept none of them, and saved the difference back over the file.\n      if (this.propertyNames.length === 0) {\n        return;\n      }\n\n      const newRecord = await this.settingsToRawRecord(this.currentState.inputValues);\n\n      if (!isDeepEqual(newRecord, data)) {\n        await this.saveToFileImpl();\n      }\n    } finally {\n      await this.asyncEvents.triggerAsync('loadSettings', this.currentState as ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad);\n    }\n  }\n\n  /**\n   * Remove an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   */\n  public off<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void {\n    this.asyncEvents.off(name, callback);\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    this.asyncEvents.offref(eventRef);\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public on<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.on(name, callback, thisArgument);\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * Add an event listener that will be called only once.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public once<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.once(name, callback, thisArgument);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * @returns A {@link Promise} that resolves when the settings are reloaded.\n   */\n  public async onExternalSettingsChange(): Promise<void> {\n    this.ensureLoaded();\n    await this.loadFromFile(false);\n  }\n\n  /**\n   * Loads settings from file and registers event handlers.\n   */\n  public override async onloadAsync(): Promise<void> {\n    registerAsyncEvent(this, this.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this, this.on('saveSettings', (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));\n    registerAsyncEvent(this, this.pluginEventSource.on('externalSettingsChange', this.onExternalSettingsChange.bind(this)));\n    await this.loadFromFile(true);\n  }\n\n  /**\n   * Registers a legacy settings converter.\n   *\n   * @typeParam LegacySettings - The legacy settings class.\n   * @param legacySettingsClass - The legacy settings class.\n   * @param converter - The converter.\n   */\n  public registerLegacySettingsConverter<LegacySettings extends object>(\n    legacySettingsClass: new () => LegacySettings,\n    converter: (legacySettings: Partial<LegacySettings> & Partial<PluginSettings>) => void\n  ): void {\n    const thisWrapper = ValueWrapper.of(this);\n    this.legacySettingsConverters.push(legacySettingsConverter);\n\n    function legacySettingsConverter(record: GenericObject): void {\n      const legacySettingsKeys = new Set<string>(Object.keys(new legacySettingsClass()));\n      const pluginSettingKeys = new Set<string>(thisWrapper.value.propertyNames);\n      const legacySettings = record as Partial<LegacySettings> & Partial<PluginSettings>;\n      converter(legacySettings);\n      for (const key of Object.keys(legacySettings)) {\n        if (pluginSettingKeys.has(key)) {\n          continue;\n        }\n\n        if (!legacySettingsKeys.has(key)) {\n          continue;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n        delete record[key];\n      }\n    }\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @typeParam PropertyName - The name of the settings property.\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  public registerValidator<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    validator: SettingsValidator<PluginSettings, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as SettingsValidator<PluginSettings>);\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns The validation messages.\n   */\n  public async revalidate(): Promise<Record<PropertyNames<PluginSettings>, string>> {\n    this.ensureLoaded();\n    await this.edit(noop);\n    return this.currentState.validationMessages;\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @param context - The context of the save to file operation.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async saveToFile(context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    if (isDeepEqual(this.lastSavedState.inputValues, this.currentState.inputValues)) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.asyncEvents.triggerAsync(\n      'saveSettings',\n      this.currentState as ReadonlyPluginSettingsState<PluginSettings>,\n      this.lastSavedState as ReadonlyPluginSettingsState<PluginSettings>,\n      context\n    );\n    this.lastSavedState = await this.cloneState(this.currentState);\n  }\n\n  /**\n   * Sets the value of a property.\n   *\n   * @typeParam PropertyName - The name of the property.\n   * @param propertyName - The name of the property.\n   * @param value - The value to set.\n   * @returns A {@link Promise} that resolves to the validation message.\n   */\n  public async setProperty<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettings[PropertyName]\n  ): Promise<string> {\n    this.ensureLoaded();\n    await this.edit((settings) => {\n      settings[propertyName] = value;\n    });\n    return this.currentState.validationMessages[propertyName];\n  }\n\n  /**\n   * Validates the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the validation result.\n   */\n  public async validate(settings: PluginSettings): Promise<ValidationResult<PluginSettings>> {\n    const result: ValidationResult<PluginSettings> = {};\n    for (const [propertyName, validator] of this.validators) {\n      const validationMessage = await validator(settings[propertyName], settings);\n      if (validationMessage) {\n        result[propertyName] = validationMessage;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Gets the transformer.\n   *\n   * @returns The transformer.\n   */\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  /**\n   * Called when the plugin settings record is loaded from disk.\n   *\n   * @param record - The record.\n   */\n  protected async onLoadRecord(record: GenericObject): Promise<void> {\n    for (const converter of this.legacySettingsConverters) {\n      converter(record);\n    }\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are loaded or reloaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether this is the initial load.\n   */\n  protected async onLoadSettings(\n    _loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    _isInitialLoad: boolean\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are saved.\n   *\n   * @param params - The parameters.\n   */\n  protected async onSaveSettings(params: PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings>): Promise<void> {\n    const {\n      context: _context,\n      newState: _newState,\n      oldState: _oldState\n    } = params;\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings record is about to be saved to disk.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers the legacy settings converters.\n   * Override to register legacy settings converters.\n   */\n  protected registerLegacySettingsConverters(): void {\n    noop();\n  }\n\n  /**\n   * Registers the validators.\n   * Override to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private async cloneSettings(settings: PluginSettings): Promise<PluginSettings> {\n    const record = await this.settingsToRawRecord(settings);\n    const json = JSON.stringify(record);\n    const cloneRecord = JSON.parse(json) as GenericObject;\n    return await this.rawRecordToSettings(cloneRecord);\n  }\n\n  private async cloneState(\n    state: PluginSettingsState<PluginSettings>\n  ): Promise<PluginSettingsState<PluginSettings>> {\n    return {\n      effectiveValues: await this.cloneSettings(state.effectiveValues),\n      inputValues: await this.cloneSettings(state.inputValues),\n      validationMessages: { ...state.validationMessages }\n    };\n  }\n\n  private createDefaultState(): PluginSettingsState<PluginSettings> {\n    return {\n      effectiveValues: new this.pluginSettingsClass(),\n      inputValues: new this.pluginSettingsClass(),\n      validationMessages: castTo<Record<PropertyNames<PluginSettings>, string>>({})\n    };\n  }\n\n  private async edit(settingsEditor: (settings: PluginSettings) => Promisable<void>): Promise<void> {\n    try {\n      await settingsEditor(this.currentState.inputValues);\n    } finally {\n      const validationResult = await this.validate(this.currentState.inputValues);\n      for (const propertyName of this.propertyNames) {\n        const validationMessage = validationResult[propertyName] ?? '';\n        this.currentState.validationMessages[propertyName] = validationMessage;\n        const defaults = this.defaultSettings as PluginSettings;\n        this.currentState.effectiveValues[propertyName] = validationMessage\n          ? defaults[propertyName]\n          : this.currentState.inputValues[propertyName];\n      }\n    }\n  }\n\n  private isValidPropertyName(property: unknown): property is PropertyNames<PluginSettings> {\n    if (typeof property !== 'string') {\n      return false;\n    }\n\n    return (this.propertyNames as string[]).includes(property);\n  }\n\n  private async rawRecordToSettings(rawRecord: GenericObject): Promise<PluginSettings> {\n    rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);\n    await this.onLoadRecord(rawRecord);\n\n    const settings = new this.pluginSettingsClass();\n    const defaults = this.defaultSettings as PluginSettings;\n\n    for (const [propertyName, value] of Object.entries(rawRecord)) {\n      if (!this.isValidPropertyName(propertyName)) {\n        getLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof defaults[propertyName]) {\n        getLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(\n          'Possible invalid value type. It might lead to an unexpected behavior of the plugin. There is also a chance it is a false-negative warning, as we are unable to determine the exact type of the value in runtime.',\n          {\n            defaultValue: defaults[propertyName],\n            propertyName,\n            value\n          }\n        );\n      }\n\n      settings[propertyName] = value as PropertyValues<PluginSettings>;\n    }\n\n    return settings;\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.dataHandler.saveData(await this.settingsToRawRecord(this.currentState.inputValues));\n  }\n\n  private setPropertyImpl(params: PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings>): void {\n    const {\n      propertyName,\n      validationMessage,\n      value\n    } = params;\n    const defaults = this.defaultSettings as PluginSettings;\n    this.currentState.inputValues[propertyName] = value;\n    this.currentState.validationMessages[propertyName] = validationMessage ?? '';\n    this.currentState.effectiveValues[propertyName] = validationMessage ? defaults[propertyName] : value;\n  }\n\n  private async settingsToRawRecord(settings: PluginSettings): Promise<GenericObject> {\n    const rawRecord: GenericObject = {};\n\n    for (const propertyName of this.propertyNames) {\n      rawRecord[propertyName] = settings[propertyName];\n    }\n\n    await this.onSavingRecord(rawRecord);\n\n    return this.getTransformer().transformObjectRecursively(rawRecord);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-settings-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that manages plugin settings: data, persistence, validation, and events.\n *\n * This is the single public-facing settings API for plugin authors.\n * All settings logic (load, save, validate, transform, clone) is handled directly\n * by this component \u2014 no separate manager class is needed.\n */\n\nimport type {\n  Constructor,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type {\n  AsyncEventRef,\n  AsyncEventSource\n} from '../../async-events.ts';\nimport type { Transformer } from '../../transformers/transformer.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../type.ts';\nimport type { DataHandler } from '../data-handler.ts';\nimport type { PluginEventSource } from '../plugin/plugin-event-source.ts';\n\nimport { AsyncEvents } from '../../async-events.ts';\nimport { getLibDebugger } from '../../debug.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport {\n  castTo,\n  getAllKeys,\n  isDeepEqual\n} from '../../object-utils.ts';\nimport { DateTransformer } from '../../transformers/date-transformer.ts';\nimport { DurationTransformer } from '../../transformers/duration-transformer.ts';\nimport { GroupTransformer } from '../../transformers/group-transformer.ts';\nimport { MapTransformer } from '../../transformers/map-transformer.ts';\nimport { SetTransformer } from '../../transformers/set-transformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../transformers/skip-private-property-transformer.ts';\nimport { TwoWayMapTransformer } from '../../transformers/two-way-map-transformer.ts';\nimport { ValueWrapper } from '../../value-wrapper.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer(),\n  new MapTransformer(),\n  new SetTransformer(),\n  new TwoWayMapTransformer()\n]);\n\n/**\n * Constructor parameters for {@link PluginSettingsComponentBase}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseConstructorParams<PluginSettings> {\n  /**\n   * The data handler for the plugin.\n   */\n  readonly dataHandler: DataHandler;\n\n  /**\n   * The plugin events.\n   */\n  readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class.\n   */\n  readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.onSaveSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseOnSaveSettingsParams<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 * A snapshot of plugin settings state, including raw input values, effective (validated) values,\n * and per-property validation messages.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsState<PluginSettings extends object> {\n  /**\n   * The effective settings values used by the plugin. Invalid properties are replaced with defaults.\n   */\n  effectiveValues: PluginSettings;\n\n  /**\n   * The raw input values as entered by the user. May contain invalid values.\n   */\n  inputValues: PluginSettings;\n\n  /**\n   * Per-property validation messages. Empty string means valid.\n   */\n  validationMessages: Record<StringKeys<PluginSettings>, string>;\n}\n\n/**\n * Readonly version of {@link PluginSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettings<PluginSettings extends object> = ReadonlyDeep<PluginSettings>;\n\n/**\n * Readonly version of {@link PluginSettingsState} for use in event callbacks and public getters.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettingsState<PluginSettings extends object> = ReadonlyDeep<PluginSettingsState<PluginSettings>>;\n\n/**\n * A validator function for a settings property.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam PropertyName - The property name.\n */\nexport type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<string>>;\n\ninterface PluginSettingsComponentBaseEventMap<PluginSettings extends object> {\n  loadSettings: [\n    loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    isInitialLoad: boolean\n  ];\n  saveSettings: [\n    newState: ReadonlyPluginSettingsState<PluginSettings>,\n    oldState: ReadonlyPluginSettingsState<PluginSettings>,\n    context: unknown\n  ];\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.setPropertyImpl}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\ninterface PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings extends object> {\n  /**\n   * The name of the property to set.\n   */\n  readonly propertyName: PropertyNames<PluginSettings>;\n\n  /**\n   * The validation message. Empty or unset means valid.\n   */\n  readonly validationMessage?: string | undefined;\n\n  /**\n   * The value to set.\n   */\n  readonly value: PropertyValues<PluginSettings>;\n}\n\ntype PropertyNames<PluginSettings extends object> = StringKeys<PluginSettings>;\n\ntype PropertyValues<PluginSettings extends object> = PluginSettings[PropertyNames<PluginSettings>];\n\ntype ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;\n\n/**\n * Base class for plugin settings components.\n *\n * Manages settings data, persistence, validation, and events.\n * Plugin authors extend this class and implement {@link createDefaultSettings}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\n// eslint-disable-next-line obsidian-dev-utils/require-component-suffix -- Non-abstract base class; consumers extend it.\nexport class PluginSettingsComponentBase<PluginSettings extends object> extends ComponentEx implements AsyncEventSource<PluginSettingsComponentBaseEventMap<PluginSettings>> {\n  /**\n   * Gets the readonly default settings.\n   *\n   * @returns The default settings (as a readonly object).\n   */\n  public readonly defaultSettings: ReadonlyDeep<PluginSettings>;\n\n  /**\n   * Gets the readonly effective settings (validated, with defaults substituted for invalid values).\n   *\n   * @returns The readonly effective settings.\n   */\n  public get settings(): ReadonlyDeep<PluginSettings> {\n    return this.settingsState.effectiveValues;\n  }\n\n  /**\n   * Gets the current settings state snapshot.\n   *\n   * @returns The current settings state.\n   */\n  public get settingsState(): ReadonlyPluginSettingsState<PluginSettings> {\n    return this.currentState as ReadonlyPluginSettingsState<PluginSettings>;\n  }\n\n  /**\n   * The data handler used to load and save the plugin settings.\n   */\n  protected readonly dataHandler: DataHandler;\n  /**\n   * The plugin event source the component listens to for external settings changes.\n   */\n  protected readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class used to construct settings instances.\n   */\n  protected readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n  private readonly asyncEvents = new AsyncEvents<PluginSettingsComponentBaseEventMap<PluginSettings>>();\n  private currentState: PluginSettingsState<PluginSettings>;\n\n  private isLoadedFromFile = false;\n\n  private lastSavedState: PluginSettingsState<PluginSettings>;\n\n  private readonly legacySettingsConverters: ((record: GenericObject) => void)[] = [];\n  private readonly loadedFromFileResolvers: (() => void)[] = [];\n  private readonly propertyNames: PropertyNames<PluginSettings>[];\n\n  private readonly validators = new Map<PropertyNames<PluginSettings>, SettingsValidator<PluginSettings>>();\n\n  /**\n   * Creates a new plugin settings component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSettingsComponentBaseConstructorParams<PluginSettings>) {\n    super();\n    this.dataHandler = params.dataHandler;\n    this.pluginSettingsClass = params.pluginSettingsClass;\n    this.pluginEventSource = params.pluginEventSource;\n\n    this.defaultSettings = new this.pluginSettingsClass() as ReadonlyDeep<PluginSettings>;\n    this.currentState = this.createDefaultState();\n    this.lastSavedState = this.createDefaultState();\n    this.propertyNames = getAllKeys(this.currentState.inputValues);\n    this.registerValidators();\n    this.registerLegacySettingsConverters();\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param settingsEditor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(settingsEditor: (settings: PluginSettings) => Promisable<void>, context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    await this.edit(settingsEditor);\n    await this.saveToFile(context);\n  }\n\n  /**\n   * Ensures the settings are safe.\n   *\n   * It runs validation for each property and sets the default value if the validation fails.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves when the settings are safe.\n   */\n  public async ensureSafe(settings: PluginSettings): Promise<void> {\n    const validationResult = await this.validate(settings);\n    const defaults = this.defaultSettings as PluginSettings;\n    for (const propertyName of this.propertyNames) {\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- This tests whether a validation message is non-empty, not whether the key exists.\n      if (validationResult[propertyName]) {\n        settings[propertyName] = defaults[propertyName];\n      }\n    }\n  }\n\n  /**\n   * Gets a safe copy of the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the safe copy of the settings.\n   */\n  public async getSafeCopy(settings: PluginSettings): Promise<PluginSettings> {\n    const safeSettings = await this.cloneSettings(settings);\n    await this.ensureSafe(safeSettings);\n    return safeSettings;\n  }\n\n  /**\n   * Loads the plugin settings from the file.\n   *\n   * @param isInitialLoad - Whether the settings are being loaded for the first time.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    this.ensureLoaded();\n    const data = await this.dataHandler.loadData();\n    this.lastSavedState = this.createDefaultState();\n    this.currentState = this.createDefaultState();\n\n    try {\n      if (data === undefined || data === null) {\n        return;\n      }\n\n      if (typeof data !== 'object') {\n        console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);\n        return;\n      }\n\n      const rawRecord = data as GenericObject;\n      const parsedSettings = await this.rawRecordToSettings(rawRecord);\n      const validationResult = await this.validate(parsedSettings);\n\n      for (const propertyName of this.propertyNames) {\n        this.setPropertyImpl({\n          propertyName,\n          validationMessage: validationResult[propertyName],\n          value: parsedSettings[propertyName]\n        });\n      }\n\n      this.lastSavedState = await this.cloneState(this.currentState);\n\n      // A component that knows no property names cannot normalize anything: `settingsToRawRecord()` can\n      // Only ever return `{}`, so the save below would not rewrite `data.json` -- it would empty it.\n      // `PluginBase` adds a placeholder `PluginSettingsComponentBase<object>` before `onloadImpl()` swaps\n      // In the plugin's own component, and that placeholder is exactly this case: it read every real\n      // Setting, kept none of them, and saved the difference back over the file.\n      if (this.propertyNames.length === 0) {\n        return;\n      }\n\n      const newRecord = await this.settingsToRawRecord(this.currentState.inputValues);\n\n      if (!isDeepEqual(newRecord, data)) {\n        await this.saveToFileImpl();\n      }\n    } finally {\n      this.markLoadedFromFile();\n      await this.asyncEvents.triggerAsync('loadSettings', this.currentState as ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad);\n    }\n  }\n\n  /**\n   * Remove an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   */\n  public off<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void {\n    this.asyncEvents.off(name, callback);\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    this.asyncEvents.offref(eventRef);\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public on<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.on(name, callback, thisArgument);\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * Add an event listener that will be called only once.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public once<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.once(name, callback, thisArgument);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * @returns A {@link Promise} that resolves when the settings are reloaded.\n   */\n  public async onExternalSettingsChange(): Promise<void> {\n    this.ensureLoaded();\n    await this.loadFromFile(false);\n  }\n\n  /**\n   * Loads settings from file and registers event handlers.\n   */\n  public override async onloadAsync(): Promise<void> {\n    registerAsyncEvent(this, this.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this, this.on('saveSettings', (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));\n    registerAsyncEvent(this, this.pluginEventSource.on('externalSettingsChange', this.onExternalSettingsChange.bind(this)));\n    await this.loadFromFile(true);\n  }\n\n  /**\n   * Registers a legacy settings converter.\n   *\n   * @typeParam LegacySettings - The legacy settings class.\n   * @param legacySettingsClass - The legacy settings class.\n   * @param converter - The converter.\n   */\n  public registerLegacySettingsConverter<LegacySettings extends object>(\n    legacySettingsClass: new () => LegacySettings,\n    converter: (legacySettings: Partial<LegacySettings> & Partial<PluginSettings>) => void\n  ): void {\n    const thisWrapper = ValueWrapper.of(this);\n    this.legacySettingsConverters.push(legacySettingsConverter);\n\n    function legacySettingsConverter(record: GenericObject): void {\n      const legacySettingsKeys = new Set<string>(Object.keys(new legacySettingsClass()));\n      const pluginSettingKeys = new Set<string>(thisWrapper.value.propertyNames);\n      const legacySettings = record as Partial<LegacySettings> & Partial<PluginSettings>;\n      converter(legacySettings);\n      for (const key of Object.keys(legacySettings)) {\n        if (pluginSettingKeys.has(key)) {\n          continue;\n        }\n\n        if (!legacySettingsKeys.has(key)) {\n          continue;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n        delete record[key];\n      }\n    }\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @typeParam PropertyName - The name of the settings property.\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  public registerValidator<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    validator: SettingsValidator<PluginSettings, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as SettingsValidator<PluginSettings>);\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns The validation messages.\n   */\n  public async revalidate(): Promise<Record<PropertyNames<PluginSettings>, string>> {\n    this.ensureLoaded();\n    await this.edit(noop);\n    return this.currentState.validationMessages;\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @param context - The context of the save to file operation.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async saveToFile(context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    if (isDeepEqual(this.lastSavedState.inputValues, this.currentState.inputValues)) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.asyncEvents.triggerAsync(\n      'saveSettings',\n      this.currentState as ReadonlyPluginSettingsState<PluginSettings>,\n      this.lastSavedState as ReadonlyPluginSettingsState<PluginSettings>,\n      context\n    );\n    this.lastSavedState = await this.cloneState(this.currentState);\n  }\n\n  /**\n   * Sets the value of a property.\n   *\n   * @typeParam PropertyName - The name of the property.\n   * @param propertyName - The name of the property.\n   * @param value - The value to set.\n   * @returns A {@link Promise} that resolves to the validation message.\n   */\n  public async setProperty<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettings[PropertyName]\n  ): Promise<string> {\n    this.ensureLoaded();\n    await this.edit((settings) => {\n      settings[propertyName] = value;\n    });\n    return this.currentState.validationMessages[propertyName];\n  }\n\n  /**\n   * Validates the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the validation result.\n   */\n  public async validate(settings: PluginSettings): Promise<ValidationResult<PluginSettings>> {\n    const result: ValidationResult<PluginSettings> = {};\n    for (const [propertyName, validator] of this.validators) {\n      const validationMessage = await validator(settings[propertyName], settings);\n      if (validationMessage) {\n        result[propertyName] = validationMessage;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Waits until the settings have been read from `data.json` at least once.\n   *\n   * Anything that reads a setting from outside this component has to wait for this, because until the first\n   * {@link loadFromFile} completes {@link settings} still holds the DEFAULTS \u2014 reading it earlier answers\n   * with a default rather than with what the user actually stored. That window is easy to miss, since it is\n   * empty on a cold start (the workspace layout is not ready yet, so nothing has run) but wide open on a\n   * runtime enable from the Community Plugins tab or a re-enable after an update, where a layout-ready\n   * handler fires immediately while this component's own async load is still in flight.\n   *\n   * Resolves immediately once the settings have loaded, so a caller that arrives late is not stranded\n   * waiting for an event that has already been raised. Later reloads (an external `data.json` change) do\n   * not reset it \u2014 the question it answers is whether the settings have EVER been read, not whether the\n   * most recent read has finished.\n   *\n   * @returns A {@link Promise} that resolves once the settings have been loaded from the file.\n   */\n  public whenLoadedFromFile(): Promise<void> {\n    if (this.isLoadedFromFile) {\n      return noopAsync();\n    }\n\n    return new Promise<void>((resolve) => {\n      this.loadedFromFileResolvers.push(resolve);\n    });\n  }\n\n  /**\n   * Gets the transformer.\n   *\n   * @returns The transformer.\n   */\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  /**\n   * Called when the plugin settings record is loaded from disk.\n   *\n   * @param record - The record.\n   */\n  protected async onLoadRecord(record: GenericObject): Promise<void> {\n    for (const converter of this.legacySettingsConverters) {\n      converter(record);\n    }\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are loaded or reloaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether this is the initial load.\n   */\n  protected async onLoadSettings(\n    _loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    _isInitialLoad: boolean\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are saved.\n   *\n   * @param params - The parameters.\n   */\n  protected async onSaveSettings(params: PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings>): Promise<void> {\n    const {\n      context: _context,\n      newState: _newState,\n      oldState: _oldState\n    } = params;\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings record is about to be saved to disk.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers the legacy settings converters.\n   * Override to register legacy settings converters.\n   */\n  protected registerLegacySettingsConverters(): void {\n    noop();\n  }\n\n  /**\n   * Registers the validators.\n   * Override to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private async cloneSettings(settings: PluginSettings): Promise<PluginSettings> {\n    const record = await this.settingsToRawRecord(settings);\n    const json = JSON.stringify(record);\n    const cloneRecord = JSON.parse(json) as GenericObject;\n    return await this.rawRecordToSettings(cloneRecord);\n  }\n\n  private async cloneState(\n    state: PluginSettingsState<PluginSettings>\n  ): Promise<PluginSettingsState<PluginSettings>> {\n    return {\n      effectiveValues: await this.cloneSettings(state.effectiveValues),\n      inputValues: await this.cloneSettings(state.inputValues),\n      validationMessages: { ...state.validationMessages }\n    };\n  }\n\n  private createDefaultState(): PluginSettingsState<PluginSettings> {\n    return {\n      effectiveValues: new this.pluginSettingsClass(),\n      inputValues: new this.pluginSettingsClass(),\n      validationMessages: castTo<Record<PropertyNames<PluginSettings>, string>>({})\n    };\n  }\n\n  private async edit(settingsEditor: (settings: PluginSettings) => Promisable<void>): Promise<void> {\n    try {\n      await settingsEditor(this.currentState.inputValues);\n    } finally {\n      const validationResult = await this.validate(this.currentState.inputValues);\n      for (const propertyName of this.propertyNames) {\n        const validationMessage = validationResult[propertyName] ?? '';\n        this.currentState.validationMessages[propertyName] = validationMessage;\n        const defaults = this.defaultSettings as PluginSettings;\n        this.currentState.effectiveValues[propertyName] = validationMessage\n          ? defaults[propertyName]\n          : this.currentState.inputValues[propertyName];\n      }\n    }\n  }\n\n  private isValidPropertyName(property: unknown): property is PropertyNames<PluginSettings> {\n    if (typeof property !== 'string') {\n      return false;\n    }\n\n    return (this.propertyNames as string[]).includes(property);\n  }\n\n  private markLoadedFromFile(): void {\n    this.isLoadedFromFile = true;\n    // Drained rather than iterated, so the list does not keep every past waiter alive across reloads.\n    const resolvers = this.loadedFromFileResolvers.splice(0);\n    for (const resolve of resolvers) {\n      resolve();\n    }\n  }\n\n  private async rawRecordToSettings(rawRecord: GenericObject): Promise<PluginSettings> {\n    rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);\n    await this.onLoadRecord(rawRecord);\n\n    const settings = new this.pluginSettingsClass();\n    const defaults = this.defaultSettings as PluginSettings;\n\n    for (const [propertyName, value] of Object.entries(rawRecord)) {\n      if (!this.isValidPropertyName(propertyName)) {\n        getLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof defaults[propertyName]) {\n        getLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(\n          'Possible invalid value type. It might lead to an unexpected behavior of the plugin. There is also a chance it is a false-negative warning, as we are unable to determine the exact type of the value in runtime.',\n          {\n            defaultValue: defaults[propertyName],\n            propertyName,\n            value\n          }\n        );\n      }\n\n      settings[propertyName] = value as PropertyValues<PluginSettings>;\n    }\n\n    return settings;\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.dataHandler.saveData(await this.settingsToRawRecord(this.currentState.inputValues));\n  }\n\n  private setPropertyImpl(params: PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings>): void {\n    const {\n      propertyName,\n      validationMessage,\n      value\n    } = params;\n    const defaults = this.defaultSettings as PluginSettings;\n    this.currentState.inputValues[propertyName] = value;\n    this.currentState.validationMessages[propertyName] = validationMessage ?? '';\n    this.currentState.effectiveValues[propertyName] = validationMessage ? defaults[propertyName] : value;\n  }\n\n  private async settingsToRawRecord(settings: PluginSettings): Promise<GenericObject> {\n    const rawRecord: GenericObject = {};\n\n    for (const propertyName of this.propertyNames) {\n      rawRecord[propertyName] = settings[propertyName];\n    }\n\n    await this.onSavingRecord(rawRecord);\n\n    return this.getTransformer().transformObjectRecursively(rawRecord);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/obsidian/components/plugin-settings-component.d.cts

@@ -147,8 +147,10 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
     protected readonly pluginSettingsClass: Constructor<PluginSettings, []>;
     private readonly asyncEvents;
     private currentState;
+    private isLoadedFromFile;
     private lastSavedState;
     private readonly legacySettingsConverters;
+    private readonly loadedFromFileResolvers;
     private readonly propertyNames;
     private readonly validators;
     /**
@@ -286,6 +288,24 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      * @returns A {@link Promise} that resolves to the validation result.
      */
     validate(settings: PluginSettings): Promise<ValidationResult<PluginSettings>>;
+    /**
+     * Waits until the settings have been read from `data.json` at least once.
+     *
+     * Anything that reads a setting from outside this component has to wait for this, because until the first
+     * {@link loadFromFile} completes {@link settings} still holds the DEFAULTS — reading it earlier answers
+     * with a default rather than with what the user actually stored. That window is easy to miss, since it is
+     * empty on a cold start (the workspace layout is not ready yet, so nothing has run) but wide open on a
+     * runtime enable from the Community Plugins tab or a re-enable after an update, where a layout-ready
+     * handler fires immediately while this component's own async load is still in flight.
+     *
+     * Resolves immediately once the settings have loaded, so a caller that arrives late is not stranded
+     * waiting for an event that has already been raised. Later reloads (an external `data.json` change) do
+     * not reset it — the question it answers is whether the settings have EVER been read, not whether the
+     * most recent read has finished.
+     *
+     * @returns A {@link Promise} that resolves once the settings have been loaded from the file.
+     */
+    whenLoadedFromFile(): Promise<void>;
     /**
      * Gets the transformer.
      *
@@ -332,6 +352,7 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
     private createDefaultState;
     private edit;
     private isValidPropertyName;
+    private markLoadedFromFile;
     private rawRecordToSettings;
     private saveToFileImpl;
     private setPropertyImpl;

package/dist/lib/cjs/obsidian/components/plugin-suggestion-component.cjs

@@ -163,6 +163,7 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
   app;
   isSuggestionDeclined;
   pluginNoticeComponent;
+  pluginSettingsComponent;
   reason;
   setSuggestionDeclined;
   suggestedPluginId;
@@ -176,6 +177,7 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
     super();
     this.app = params.app;
     this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.pluginSettingsComponent = params.pluginSettingsComponent;
     this.reason = params.reason;
     this.suggestedPluginId = params.suggestedPluginId;
     this.suggestedPluginName = params.suggestedPluginName;
@@ -228,15 +230,27 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
     }));
   }
   /**
-   * Loads the component, showing the suggestion notice once the layout is ready.
+   * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings
+   * have been read from disk.
    *
-   * The wait matters: plugins load in an unspecified order, so the suggested plugin may well be enabled
-   * a moment after this one. Checking before the layout is ready would suggest installing something the
-   * user already has.
+   * Both waits matter, and neither implies the other:
+   *
+   * - Layout-ready, because plugins load in an unspecified order, so the suggested plugin may well be
+   *   enabled a moment after this one. Checking earlier would suggest installing something the user
+   *   already has.
+   * - Settings-loaded, because {@link PluginSuggestionComponentConstructorParams.isSuggestionDeclined}
+   *   reads a setting of the host, and the host's settings component is a SIBLING whose own async load is
+   *   still in flight here. On a layout that is already ready — a runtime enable from the Community
+   *   Plugins tab, or a re-enable after an update — the layout-ready callback fires immediately, so the
+   *   read would see the default `false` and ask again a user who has already declined.
    */
   onload() {
     this.addChild(
-      new import_layout_ready_component.CallbackLayoutReadyComponent(this.app, () => {
+      new import_layout_ready_component.CallbackLayoutReadyComponent(this.app, async () => {
+        await this.pluginSettingsComponent.whenLoadedFromFile();
+        if (this.isUnloaded()) {
+          return;
+        }
         this.showSuggestionNotice();
       })
     );
@@ -292,4 +306,4 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
   PluginSuggestionComponent,
   SuggestedPluginState
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-suggestion-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that suggests installing another community plugin the host plugin needs in order to offer\n * some of its behavior.\n *\n * A suggestion is not a dependency. Obsidian has no mechanism for one community plugin to require\n * another, and inventing one by refusing to load would punish the user for something they never agreed\n * to. So the host plugin keeps working without the suggested plugin \u2014 it simply cannot offer whatever\n * that plugin owns \u2014 and this component asks, once, whether the user would like it installed.\n *\n * The ask is surfaced twice, deliberately, because the two placements answer different questions:\n * a notice on load (\"you are missing something you probably want\") and a settings-tab banner (\"the\n * settings you came looking for live in another plugin\"). Declining silences only the notice \u2014 a user\n * who opens the settings tab is asking about the feature right then, so the banner stays.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { ButtonComponent } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\n\nimport { convertAsyncToSync } from '../../async.ts';\nimport {\n  enableCommunityPlugin,\n  installConfigureEnableCommunityPlugin\n} from '../community-plugins.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { CallbackLayoutReadyComponent } from './layout-ready-component.ts';\n\n/**\n * How the suggested plugin is currently present in the vault.\n */\nexport enum SuggestedPluginState {\n  /**\n   * Installed and enabled \u2014 there is nothing to suggest.\n   */\n  Enabled = 'enabled',\n\n  /**\n   * Installed but disabled. Only an enable is needed, so no download happens.\n   */\n  InstalledButDisabled = 'installedButDisabled',\n\n  /**\n   * Not installed at all.\n   */\n  NotInstalled = 'notInstalled'\n}\n\n/**\n * Parameters for the {@link PluginSuggestionComponent} constructor.\n */\nexport interface PluginSuggestionComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether the user has already declined this suggestion.\n   *\n   * Storage belongs to the host plugin (typically one of its settings), because this component has no\n   * `data.json` of its own and a decline has to outlive a reload.\n   *\n   * @returns `true` when the suggestion has been declined.\n   */\n  isSuggestionDeclined(this: void): boolean;\n\n  /**\n   * The notice component of the plugin making the suggestion, used to show the suggestion and its\n   * outcome.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The localized sentence explaining what the host plugin cannot do without the suggested plugin. The\n   * host plugin owns this string: only it knows which of its features are affected.\n   */\n  readonly reason: string;\n\n  /**\n   * Records the user's answer to the suggestion.\n   *\n   * @param isDeclined - `true` when the user declined.\n   * @returns A {@link Promise} that resolves once the answer is persisted.\n   */\n  setSuggestionDeclined(this: void, isDeclined: boolean): Promisable<void>;\n\n  /**\n   * The id of the suggested plugin, as listed in Obsidian's community plugin registry.\n   */\n  readonly suggestedPluginId: string;\n\n  /**\n   * The display name of the suggested plugin, shown to the user.\n   */\n  readonly suggestedPluginName: string;\n}\n\n/**\n * Suggests installing another community plugin, via a load-time notice and a settings-tab banner.\n */\nexport class PluginSuggestionComponent extends ComponentEx {\n  private readonly app: App;\n  private readonly isSuggestionDeclined: () => boolean;\n  private readonly pluginNoticeComponent: PluginNoticeComponent;\n  private readonly reason: string;\n  private readonly setSuggestionDeclined: (isDeclined: boolean) => Promisable<void>;\n  private readonly suggestedPluginId: string;\n  private readonly suggestedPluginName: string;\n\n  /**\n   * Creates an instance of {@link PluginSuggestionComponent}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSuggestionComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.reason = params.reason;\n    this.suggestedPluginId = params.suggestedPluginId;\n    this.suggestedPluginName = params.suggestedPluginName;\n    this.isSuggestionDeclined = params.isSuggestionDeclined;\n    this.setSuggestionDeclined = params.setSuggestionDeclined;\n  }\n\n  /**\n   * Resolves how the suggested plugin is currently present in the vault.\n   *\n   * @returns The {@link SuggestedPluginState}.\n   */\n  public getSuggestedPluginState(): SuggestedPluginState {\n    if (this.app.plugins.enabledPlugins.has(this.suggestedPluginId)) {\n      return SuggestedPluginState.Enabled;\n    }\n\n    return Object.hasOwn(this.app.plugins.manifests, this.suggestedPluginId)\n      ? SuggestedPluginState.InstalledButDisabled\n      : SuggestedPluginState.NotInstalled;\n  }\n\n  /**\n   * Installs (when needed) and enables the suggested plugin, reporting the outcome as a notice.\n   *\n   * @returns A {@link Promise} that resolves once the plugin is enabled, or once the failure has been\n   * reported.\n   */\n  public async installAndEnableSuggestedPlugin(): Promise<void> {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled) {\n      return;\n    }\n\n    try {\n      if (state === SuggestedPluginState.InstalledButDisabled) {\n        await enableCommunityPlugin({\n          app: this.app,\n          pluginId: this.suggestedPluginId\n        });\n      } else {\n        await installConfigureEnableCommunityPlugin({\n          app: this.app,\n          pluginId: this.suggestedPluginId\n        });\n      }\n    } catch (error) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.pluginSuggestion.installFailed, {\n        pluginName: this.suggestedPluginName\n      }));\n      throw error;\n    }\n\n    await this.setSuggestionDeclined(false);\n    this.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.pluginSuggestion.installed, {\n      pluginName: this.suggestedPluginName\n    }));\n  }\n\n  /**\n   * Loads the component, showing the suggestion notice once the layout is ready.\n   *\n   * The wait matters: plugins load in an unspecified order, so the suggested plugin may well be enabled\n   * a moment after this one. Checking before the layout is ready would suggest installing something the\n   * user already has.\n   */\n  public override onload(): void {\n    this.addChild(\n      new CallbackLayoutReadyComponent(this.app, () => {\n        this.showSuggestionNotice();\n      })\n    );\n  }\n\n  /**\n   * Renders the suggestion banner into a settings-tab container, with a button that installs and enables\n   * the suggested plugin.\n   *\n   * Renders nothing when the suggested plugin is already enabled. Unlike the notice, the banner ignores a\n   * previous decline \u2014 the user is looking at these settings right now, which is a fresher signal than an\n   * answer they gave earlier.\n   *\n   * @param containerEl - The element to render the banner into.\n   */\n  public renderBanner(containerEl: HTMLElement): void {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled) {\n      return;\n    }\n\n    const bannerEl = containerEl.createDiv({\n      cls: [CssClass.LibraryName, CssClass.PluginSuggestionBanner]\n    });\n    bannerEl.createDiv({ text: this.reason });\n\n    new ButtonComponent(bannerEl)\n      .setButtonText(this.getActionButtonText(state))\n      .setCta()\n      .onClick(convertAsyncToSync(async () => {\n        await this.installAndEnableSuggestedPlugin();\n      }));\n  }\n\n  private getActionButtonText(state: SuggestedPluginState): string {\n    return t(($) =>\n      state === SuggestedPluginState.InstalledButDisabled\n        ? $.obsidianDevUtils.pluginSuggestion.enable\n        : $.obsidianDevUtils.pluginSuggestion.install\n    );\n  }\n\n  private showSuggestionNotice(): void {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled || this.isSuggestionDeclined()) {\n      return;\n    }\n\n    const fragment = createFragment((fragmentEl) => {\n      fragmentEl.createDiv({ text: this.reason });\n      const buttonsEl = fragmentEl.createDiv();\n\n      new ButtonComponent(buttonsEl)\n        .setButtonText(this.getActionButtonText(state))\n        .setCta()\n        .onClick(convertAsyncToSync(async () => {\n          await this.installAndEnableSuggestedPlugin();\n        }));\n\n      new ButtonComponent(buttonsEl)\n        .setButtonText(t(($) => $.obsidianDevUtils.pluginSuggestion.notNow))\n        .onClick(convertAsyncToSync(async () => {\n          await this.setSuggestionDeclined(true);\n        }));\n    });\n\n    this.pluginNoticeComponent.showNotice(fragment, { shouldHideOnClick: false });\n  }\n}\n"],
  "mappings": "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",
  "names": ["SuggestedPluginState"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-suggestion-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that suggests installing another community plugin the host plugin needs in order to offer\n * some of its behavior.\n *\n * A suggestion is not a dependency. Obsidian has no mechanism for one community plugin to require\n * another, and inventing one by refusing to load would punish the user for something they never agreed\n * to. So the host plugin keeps working without the suggested plugin \u2014 it simply cannot offer whatever\n * that plugin owns \u2014 and this component asks, once, whether the user would like it installed.\n *\n * The ask is surfaced twice, deliberately, because the two placements answer different questions:\n * a notice on load (\"you are missing something you probably want\") and a settings-tab banner (\"the\n * settings you came looking for live in another plugin\"). Declining silences only the notice \u2014 a user\n * who opens the settings tab is asking about the feature right then, so the banner stays.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { ButtonComponent } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\nimport type { PluginSettingsComponentBase } from './plugin-settings-component.ts';\n\nimport { convertAsyncToSync } from '../../async.ts';\nimport {\n  enableCommunityPlugin,\n  installConfigureEnableCommunityPlugin\n} from '../community-plugins.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { CallbackLayoutReadyComponent } from './layout-ready-component.ts';\n\n/**\n * How the suggested plugin is currently present in the vault.\n */\nexport enum SuggestedPluginState {\n  /**\n   * Installed and enabled \u2014 there is nothing to suggest.\n   */\n  Enabled = 'enabled',\n\n  /**\n   * Installed but disabled. Only an enable is needed, so no download happens.\n   */\n  InstalledButDisabled = 'installedButDisabled',\n\n  /**\n   * Not installed at all.\n   */\n  NotInstalled = 'notInstalled'\n}\n\n/**\n * Parameters for the {@link PluginSuggestionComponent} constructor.\n */\nexport interface PluginSuggestionComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether the user has already declined this suggestion.\n   *\n   * Storage belongs to the host plugin (typically one of its settings), because this component has no\n   * `data.json` of its own and a decline has to outlive a reload.\n   *\n   * Only ever called once {@link pluginSettingsComponent} reports its settings loaded, so an implementation\n   * reading a setting is guaranteed to read the stored value rather than its default.\n   *\n   * @returns `true` when the suggestion has been declined.\n   */\n  isSuggestionDeclined(this: void): boolean;\n\n  /**\n   * The notice component of the plugin making the suggestion, used to show the suggestion and its\n   * outcome.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The settings component holding whatever {@link isSuggestionDeclined} reads.\n   *\n   * Taken as a whole component rather than as a bare \"ready\" flag so the host cannot forget to wire the\n   * wait: the notice is decided only after this component has read `data.json`. See\n   * {@link PluginSettingsComponentBase.whenLoadedFromFile} for why the read cannot simply happen at\n   * layout-ready.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n\n  /**\n   * The localized sentence explaining what the host plugin cannot do without the suggested plugin. The\n   * host plugin owns this string: only it knows which of its features are affected.\n   */\n  readonly reason: string;\n\n  /**\n   * Records the user's answer to the suggestion.\n   *\n   * @param isDeclined - `true` when the user declined.\n   * @returns A {@link Promise} that resolves once the answer is persisted.\n   */\n  setSuggestionDeclined(this: void, isDeclined: boolean): Promisable<void>;\n\n  /**\n   * The id of the suggested plugin, as listed in Obsidian's community plugin registry.\n   */\n  readonly suggestedPluginId: string;\n\n  /**\n   * The display name of the suggested plugin, shown to the user.\n   */\n  readonly suggestedPluginName: string;\n}\n\n/**\n * Suggests installing another community plugin, via a load-time notice and a settings-tab banner.\n */\nexport class PluginSuggestionComponent extends ComponentEx {\n  private readonly app: App;\n  private readonly isSuggestionDeclined: () => boolean;\n  private readonly pluginNoticeComponent: PluginNoticeComponent;\n  private readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n  private readonly reason: string;\n  private readonly setSuggestionDeclined: (isDeclined: boolean) => Promisable<void>;\n  private readonly suggestedPluginId: string;\n  private readonly suggestedPluginName: string;\n\n  /**\n   * Creates an instance of {@link PluginSuggestionComponent}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSuggestionComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    this.reason = params.reason;\n    this.suggestedPluginId = params.suggestedPluginId;\n    this.suggestedPluginName = params.suggestedPluginName;\n    this.isSuggestionDeclined = params.isSuggestionDeclined;\n    this.setSuggestionDeclined = params.setSuggestionDeclined;\n  }\n\n  /**\n   * Resolves how the suggested plugin is currently present in the vault.\n   *\n   * @returns The {@link SuggestedPluginState}.\n   */\n  public getSuggestedPluginState(): SuggestedPluginState {\n    if (this.app.plugins.enabledPlugins.has(this.suggestedPluginId)) {\n      return SuggestedPluginState.Enabled;\n    }\n\n    return Object.hasOwn(this.app.plugins.manifests, this.suggestedPluginId)\n      ? SuggestedPluginState.InstalledButDisabled\n      : SuggestedPluginState.NotInstalled;\n  }\n\n  /**\n   * Installs (when needed) and enables the suggested plugin, reporting the outcome as a notice.\n   *\n   * @returns A {@link Promise} that resolves once the plugin is enabled, or once the failure has been\n   * reported.\n   */\n  public async installAndEnableSuggestedPlugin(): Promise<void> {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled) {\n      return;\n    }\n\n    try {\n      if (state === SuggestedPluginState.InstalledButDisabled) {\n        await enableCommunityPlugin({\n          app: this.app,\n          pluginId: this.suggestedPluginId\n        });\n      } else {\n        await installConfigureEnableCommunityPlugin({\n          app: this.app,\n          pluginId: this.suggestedPluginId\n        });\n      }\n    } catch (error) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.pluginSuggestion.installFailed, {\n        pluginName: this.suggestedPluginName\n      }));\n      throw error;\n    }\n\n    await this.setSuggestionDeclined(false);\n    this.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.pluginSuggestion.installed, {\n      pluginName: this.suggestedPluginName\n    }));\n  }\n\n  /**\n   * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings\n   * have been read from disk.\n   *\n   * Both waits matter, and neither implies the other:\n   *\n   * - Layout-ready, because plugins load in an unspecified order, so the suggested plugin may well be\n   *   enabled a moment after this one. Checking earlier would suggest installing something the user\n   *   already has.\n   * - Settings-loaded, because {@link PluginSuggestionComponentConstructorParams.isSuggestionDeclined}\n   *   reads a setting of the host, and the host's settings component is a SIBLING whose own async load is\n   *   still in flight here. On a layout that is already ready \u2014 a runtime enable from the Community\n   *   Plugins tab, or a re-enable after an update \u2014 the layout-ready callback fires immediately, so the\n   *   read would see the default `false` and ask again a user who has already declined.\n   */\n  public override onload(): void {\n    this.addChild(\n      new CallbackLayoutReadyComponent(this.app, async () => {\n        await this.pluginSettingsComponent.whenLoadedFromFile();\n        if (this.isUnloaded()) {\n          return;\n        }\n\n        this.showSuggestionNotice();\n      })\n    );\n  }\n\n  /**\n   * Renders the suggestion banner into a settings-tab container, with a button that installs and enables\n   * the suggested plugin.\n   *\n   * Renders nothing when the suggested plugin is already enabled. Unlike the notice, the banner ignores a\n   * previous decline \u2014 the user is looking at these settings right now, which is a fresher signal than an\n   * answer they gave earlier.\n   *\n   * @param containerEl - The element to render the banner into.\n   */\n  public renderBanner(containerEl: HTMLElement): void {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled) {\n      return;\n    }\n\n    const bannerEl = containerEl.createDiv({\n      cls: [CssClass.LibraryName, CssClass.PluginSuggestionBanner]\n    });\n    bannerEl.createDiv({ text: this.reason });\n\n    new ButtonComponent(bannerEl)\n      .setButtonText(this.getActionButtonText(state))\n      .setCta()\n      .onClick(convertAsyncToSync(async () => {\n        await this.installAndEnableSuggestedPlugin();\n      }));\n  }\n\n  private getActionButtonText(state: SuggestedPluginState): string {\n    return t(($) =>\n      state === SuggestedPluginState.InstalledButDisabled\n        ? $.obsidianDevUtils.pluginSuggestion.enable\n        : $.obsidianDevUtils.pluginSuggestion.install\n    );\n  }\n\n  private showSuggestionNotice(): void {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled || this.isSuggestionDeclined()) {\n      return;\n    }\n\n    const fragment = createFragment((fragmentEl) => {\n      fragmentEl.createDiv({ text: this.reason });\n      const buttonsEl = fragmentEl.createDiv();\n\n      new ButtonComponent(buttonsEl)\n        .setButtonText(this.getActionButtonText(state))\n        .setCta()\n        .onClick(convertAsyncToSync(async () => {\n          await this.installAndEnableSuggestedPlugin();\n        }));\n\n      new ButtonComponent(buttonsEl)\n        .setButtonText(t(($) => $.obsidianDevUtils.pluginSuggestion.notNow))\n        .onClick(convertAsyncToSync(async () => {\n          await this.setSuggestionDeclined(true);\n        }));\n    });\n\n    this.pluginNoticeComponent.showNotice(fragment, { shouldHideOnClick: false });\n  }\n}\n"],
  "mappings": "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",
  "names": ["SuggestedPluginState"]
}


package/dist/lib/cjs/obsidian/components/plugin-suggestion-component.d.cts

@@ -18,6 +18,7 @@
 import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
 import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { PluginNoticeComponent } from './plugin-notice-component.cjs';
+import type { PluginSettingsComponentBase } from './plugin-settings-component.cjs';
 import { ComponentEx } from './component-ex.cjs';
 /**
  * How the suggested plugin is currently present in the vault.
@@ -50,6 +51,9 @@ export interface PluginSuggestionComponentConstructorParams {
      * Storage belongs to the host plugin (typically one of its settings), because this component has no
      * `data.json` of its own and a decline has to outlive a reload.
      *
+     * Only ever called once {@link pluginSettingsComponent} reports its settings loaded, so an implementation
+     * reading a setting is guaranteed to read the stored value rather than its default.
+     *
      * @returns `true` when the suggestion has been declined.
      */
     isSuggestionDeclined(this: void): boolean;
@@ -58,6 +62,15 @@ export interface PluginSuggestionComponentConstructorParams {
      * outcome.
      */
     readonly pluginNoticeComponent: PluginNoticeComponent;
+    /**
+     * The settings component holding whatever {@link isSuggestionDeclined} reads.
+     *
+     * Taken as a whole component rather than as a bare "ready" flag so the host cannot forget to wire the
+     * wait: the notice is decided only after this component has read `data.json`. See
+     * {@link PluginSettingsComponentBase.whenLoadedFromFile} for why the read cannot simply happen at
+     * layout-ready.
+     */
+    readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;
     /**
      * The localized sentence explaining what the host plugin cannot do without the suggested plugin. The
      * host plugin owns this string: only it knows which of its features are affected.
@@ -86,6 +99,7 @@ export declare class PluginSuggestionComponent extends ComponentEx {
     private readonly app;
     private readonly isSuggestionDeclined;
     private readonly pluginNoticeComponent;
+    private readonly pluginSettingsComponent;
     private readonly reason;
     private readonly setSuggestionDeclined;
     private readonly suggestedPluginId;
@@ -110,11 +124,19 @@ export declare class PluginSuggestionComponent extends ComponentEx {
      */
     installAndEnableSuggestedPlugin(): Promise<void>;
     /**
-     * Loads the component, showing the suggestion notice once the layout is ready.
+     * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings
+     * have been read from disk.
+     *
+     * Both waits matter, and neither implies the other:
      *
-     * The wait matters: plugins load in an unspecified order, so the suggested plugin may well be enabled
-     * a moment after this one. Checking before the layout is ready would suggest installing something the
-     * user already has.
+     * - Layout-ready, because plugins load in an unspecified order, so the suggested plugin may well be
+     *   enabled a moment after this one. Checking earlier would suggest installing something the user
+     *   already has.
+     * - Settings-loaded, because {@link PluginSuggestionComponentConstructorParams.isSuggestionDeclined}
+     *   reads a setting of the host, and the host's settings component is a SIBLING whose own async load is
+     *   still in flight here. On a layout that is already ready — a runtime enable from the Community
+     *   Plugins tab, or a re-enable after an update — the layout-ready callback fires immediately, so the
+     *   read would see the default `false` and ask again a user who has already declined.
      */
     onload(): void;
     /**