obsidian-dev-utils 101.4.1 → 101.6.0

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

@@ -0,0 +1,232 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= keepName;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var settings_migration_component_exports = {};
+__export(settings_migration_component_exports, {
+  SettingsMigrationComponent: () => SettingsMigrationComponent
+});
+module.exports = __toCommonJS(settings_migration_component_exports);
+var import_async = require('../../async.cjs');
+var import_object_utils = require('../../object-utils.cjs');
+var import_plugin_api = require('../plugin/plugin-api.cjs');
+var import_async_events_component = require('./async-events-component.cjs');
+var import_component_ex = require('./component-ex.cjs');
+class SettingsMigrationComponent extends import_component_ex.ComponentEx {
+  apiVersionRange;
+  app;
+  contract;
+  getProposedSettings;
+  isProposing = false;
+  pluginSettingsComponent;
+  providerPluginId;
+  retireProposedSettings;
+  sourcePluginId;
+  /**
+   * Creates an instance of {@link SettingsMigrationComponent}.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super();
+    this.apiVersionRange = params.apiVersionRange;
+    this.app = params.app;
+    this.contract = params.contract;
+    this.getProposedSettings = params.getProposedSettings;
+    this.pluginSettingsComponent = params.pluginSettingsComponent;
+    this.providerPluginId = params.providerPluginId;
+    this.retireProposedSettings = params.retireProposedSettings;
+    this.sourcePluginId = params.sourcePluginId;
+  }
+  /**
+   * Loads the component, wiring both edges that can make an offer possible.
+   */
+  onload() {
+    const ref = (0, import_plugin_api.watchPluginApi)((0, import_object_utils.normalizeOptionalProperties)({
+      apiVersionRange: this.apiVersionRange,
+      app: this.app,
+      component: this,
+      contract: this.contract,
+      pluginId: this.providerPluginId
+    }));
+    (0, import_async_events_component.registerAsyncEvent)(
+      this,
+      ref.on("change", () => {
+        this.handleChange(ref);
+      })
+    );
+    (0, import_async_events_component.registerAsyncEvent)(
+      this,
+      this.pluginSettingsComponent.on("loadSettings", () => {
+        this.handleChange(ref);
+      })
+    );
+    this.handleChange(ref);
+  }
+  handleChange(ref) {
+    (0, import_async.invokeAsyncSafely)(async () => {
+      await this.propose(ref.value);
+    });
+  }
+  async propose(api) {
+    const proposedSettings = this.getProposedSettings();
+    if (!api || this.isProposing || proposedSettings === null) {
+      return;
+    }
+    this.isProposing = true;
+    try {
+      const result = await api.migrateSettings({
+        proposedSettings,
+        sourcePluginId: this.sourcePluginId
+      });
+      if (result.isApplied) {
+        await this.retireProposedSettings();
+      }
+    } finally {
+      this.isProposing = false;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SettingsMigrationComponent
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/settings-migration-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that offers settings this plugin used to own to the plugin that owns them now, once, through\n * that plugin's public API.\n *\n * This is the other half of {@link obsidian/components/plugin-suggestion-component!PluginSuggestionComponent}.\n * The suggestion asks the user to install the plugin that took a feature over; this carries the settings they\n * had configured for it across, so taking the suggestion does not mean re-entering everything by hand.\n *\n * A proposing plugin never writes into another plugin's `data.json`. It PROPOSES: the other plugin owns the\n * settings, so it owns the dialog, and the user approves, edits or declines. Only an applied migration retires\n * the pending values.\n *\n * The offer is made whenever it CAN succeed, which needs two independent things to have happened \u2014 the\n * provider's API being available, and this plugin's own settings having arrived from disk. Either can land\n * first, so both edges are wired and each re-reads the current state rather than assuming the other has\n * already happened.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport type {\n  PluginApiContract,\n  PluginApiRef,\n  WatchPluginApiParams\n} from '../plugin/plugin-api.ts';\nimport type { SettingsMigrationApi } from '../plugin/settings-migration-api.ts';\nimport type { PluginSettingsComponentBase } from './plugin-settings-component.ts';\n\nimport { invokeAsyncSafely } from '../../async.ts';\nimport { normalizeOptionalProperties } from '../../object-utils.ts';\nimport { watchPluginApi } from '../plugin/plugin-api.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * Parameters for the {@link SettingsMigrationComponent} constructor.\n *\n * @typeParam TMigratableSettings - The settings this plugin may hand over.\n */\nexport interface SettingsMigrationComponentConstructorParams<TMigratableSettings extends object> {\n  /**\n   * The semver range of contract versions this plugin compiled against, e.g. `'^1'`.\n   *\n   * @remarks\n   * Evaluated by `compare-versions`, which does NOT accept a bare `*`. Spell \"any version\" as `'>=0.0.0'`.\n   */\n  readonly apiVersionRange: string;\n\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The contract this plugin expects of the provider, which wins over the provider's own when supplied.\n   *\n   * Worth supplying, and worth keeping NARROW. A migration usually needs one method that has existed since the\n   * provider's first contract version, while the same plugin may read other parts of that API through a much\n   * newer one. Declaring the wider expectation here would refuse to offer the migration to a user on an older\n   * provider \u2014 which is precisely the user who still has settings to migrate.\n   */\n  readonly contract?: PluginApiContract;\n\n  /**\n   * Reads the values currently waiting to be handed over.\n   *\n   * Called afresh on every edge rather than once, so an implementation simply reads its plugin's settings.\n   * Return `null` when there is nothing pending \u2014 after a migration has been applied, or on a vault that never\n   * had these settings configured.\n   *\n   * @returns The values to propose, or `null` when there is nothing to offer.\n   */\n  getProposedSettings(this: void): null | TMigratableSettings;\n\n  /**\n   * The settings component of the plugin making the proposal.\n   *\n   * Taken as a whole component rather than as a bare \"ready\" flag so the host cannot forget to wire the wait:\n   * whatever {@link getProposedSettings} reads is meaningless until this component has read `data.json`.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n\n  /**\n   * The `manifest.id` of the plugin that owns these settings now, as listed in Obsidian's community plugin\n   * registry.\n   */\n  readonly providerPluginId: string;\n\n  /**\n   * Records that the pending values have been handed over, so the offer is not made again.\n   *\n   * Called ONLY when the user actually applied the migration.\n   *\n   * @returns A {@link Promise} that resolves once the retirement is persisted.\n   *\n   * @remarks\n   * An implementation must PERSIST the retirement \u2014 `pluginSettingsComponent.editAndSave(\u2026)`, not\n   * `setProperty(\u2026)`. The latter only edits the in-memory state, so the retirement is forgotten on the next\n   * reload and the migration is offered again forever.\n   */\n  retireProposedSettings(this: void): Promisable<void>;\n\n  /**\n   * The `manifest.id` of the plugin making the proposal, so the provider's dialog can say whose settings these\n   * are.\n   */\n  readonly sourcePluginId: string;\n}\n\n/**\n * Offers settings this plugin used to own to the plugin that owns them now.\n *\n * @typeParam TMigratableSettings - The settings this plugin may hand over.\n */\nexport class SettingsMigrationComponent<TMigratableSettings extends object> extends ComponentEx {\n  private readonly apiVersionRange: string;\n  private readonly app: App;\n  private readonly contract: PluginApiContract | undefined;\n  private readonly getProposedSettings: () => null | TMigratableSettings;\n  private isProposing = false;\n  private readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n  private readonly providerPluginId: string;\n  private readonly retireProposedSettings: () => Promisable<void>;\n  private readonly sourcePluginId: string;\n\n  /**\n   * Creates an instance of {@link SettingsMigrationComponent}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: SettingsMigrationComponentConstructorParams<TMigratableSettings>) {\n    super();\n    this.apiVersionRange = params.apiVersionRange;\n    this.app = params.app;\n    this.contract = params.contract;\n    this.getProposedSettings = params.getProposedSettings;\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    this.providerPluginId = params.providerPluginId;\n    this.retireProposedSettings = params.retireProposedSettings;\n    this.sourcePluginId = params.sourcePluginId;\n  }\n\n  /**\n   * Loads the component, wiring both edges that can make an offer possible.\n   */\n  public override onload(): void {\n    // Nothing is gated on the pending values HERE. The settings component is a sibling whose own load is still\n    // In flight at this point, so it still holds the DEFAULTS \u2014 reading the pending values now would see\n    // Nothing on exactly the vaults that have something, register no watch, and lose the migration for good.\n    // Both edges are wired instead, and `propose` re-reads the values each time it runs.\n    const ref = watchPluginApi<SettingsMigrationApi<TMigratableSettings>>(normalizeOptionalProperties<WatchPluginApiParams>({\n      apiVersionRange: this.apiVersionRange,\n      app: this.app,\n      component: this,\n      contract: this.contract,\n      pluginId: this.providerPluginId\n    }));\n\n    // Driven by the ref's own event rather than by `whenAvailable()`, deliberately. That wait blocks for ten\n    // Seconds and then throws when the provider is simply not installed, which would stall this plugin's load\n    // For every user who declines the suggestion. Watching costs nothing while the provider is absent and\n    // Offers the migration the moment it appears \u2014 including right after the user installs it from the\n    // Suggestion banner.\n    registerAsyncEvent(\n      this,\n      ref.on('change', () => {\n        this.handleChange(ref);\n      })\n    );\n\n    // The second edge: this plugin's own settings arriving from disk. It may fire before or after the first.\n    registerAsyncEvent(\n      this,\n      this.pluginSettingsComponent.on('loadSettings', () => {\n        this.handleChange(ref);\n      })\n    );\n\n    this.handleChange(ref);\n  }\n\n  private handleChange(ref: PluginApiRef<SettingsMigrationApi<TMigratableSettings>>): void {\n    invokeAsyncSafely(async () => {\n      await this.propose(ref.value);\n    });\n  }\n\n  private async propose(api: null | SettingsMigrationApi<TMigratableSettings>): Promise<void> {\n    const proposedSettings = this.getProposedSettings();\n    if (!api || this.isProposing || proposedSettings === null) {\n      return;\n    }\n\n    // Both edges can fire while the provider's dialog is open, and each would raise a second one.\n    this.isProposing = true;\n    try {\n      const result = await api.migrateSettings({\n        proposedSettings,\n        sourcePluginId: this.sourcePluginId\n      });\n\n      // A cancel is not an answer, so the values stay pending and the offer comes back \u2014 on the next load, or\n      // As soon as the provider reloads. Only an applied migration retires them.\n      if (result.isApplied) {\n        await this.retireProposedSettings();\n      }\n    } finally {\n      this.isProposing = false;\n    }\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BA,mBAAkC;AAClC,0BAA4C;AAC5C,wBAA+B;AAC/B,oCAAmC;AACnC,0BAA4B;AAkFrB,MAAM,mCAAuE,gCAAY;AAAA,EAC7E;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACT,cAAc;AAAA,EACL;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAA0E;AAC3F,UAAM;AACN,SAAK,kBAAkB,OAAO;AAC9B,SAAK,MAAM,OAAO;AAClB,SAAK,WAAW,OAAO;AACvB,SAAK,sBAAsB,OAAO;AAClC,SAAK,0BAA0B,OAAO;AACtC,SAAK,mBAAmB,OAAO;AAC/B,SAAK,yBAAyB,OAAO;AACrC,SAAK,iBAAiB,OAAO;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA,EAKgB,SAAe;AAK7B,UAAM,UAAM,sCAA0D,iDAAkD;AAAA,MACtH,iBAAiB,KAAK;AAAA,MACtB,KAAK,KAAK;AAAA,MACV,WAAW;AAAA,MACX,UAAU,KAAK;AAAA,MACf,UAAU,KAAK;AAAA,IACjB,CAAC,CAAC;AAOF;AAAA,MACE;AAAA,MACA,IAAI,GAAG,UAAU,MAAM;AACrB,aAAK,aAAa,GAAG;AAAA,MACvB,CAAC;AAAA,IACH;AAGA;AAAA,MACE;AAAA,MACA,KAAK,wBAAwB,GAAG,gBAAgB,MAAM;AACpD,aAAK,aAAa,GAAG;AAAA,MACvB,CAAC;AAAA,IACH;AAEA,SAAK,aAAa,GAAG;AAAA,EACvB;AAAA,EAEQ,aAAa,KAAoE;AACvF,wCAAkB,YAAY;AAC5B,YAAM,KAAK,QAAQ,IAAI,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,QAAQ,KAAsE;AAC1F,UAAM,mBAAmB,KAAK,oBAAoB;AAClD,QAAI,CAAC,OAAO,KAAK,eAAe,qBAAqB,MAAM;AACzD;AAAA,IACF;AAGA,SAAK,cAAc;AACnB,QAAI;AACF,YAAM,SAAS,MAAM,IAAI,gBAAgB;AAAA,QACvC;AAAA,QACA,gBAAgB,KAAK;AAAA,MACvB,CAAC;AAID,UAAI,OAAO,WAAW;AACpB,cAAM,KAAK,uBAAuB;AAAA,MACpC;AAAA,IACF,UAAE;AACA,WAAK,cAAc;AAAA,IACrB;AAAA,EACF;AACF;",
  "names": []
}


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

@@ -0,0 +1,120 @@
+/// <reference path="../../library.d.cts" />
+/**
+ * @file
+ *
+ * Component that offers settings this plugin used to own to the plugin that owns them now, once, through
+ * that plugin's public API.
+ *
+ * This is the other half of {@link obsidian/components/plugin-suggestion-component!PluginSuggestionComponent}.
+ * The suggestion asks the user to install the plugin that took a feature over; this carries the settings they
+ * had configured for it across, so taking the suggestion does not mean re-entering everything by hand.
+ *
+ * A proposing plugin never writes into another plugin's `data.json`. It PROPOSES: the other plugin owns the
+ * settings, so it owns the dialog, and the user approves, edits or declines. Only an applied migration retires
+ * the pending values.
+ *
+ * The offer is made whenever it CAN succeed, which needs two independent things to have happened — the
+ * provider's API being available, and this plugin's own settings having arrived from disk. Either can land
+ * first, so both edges are wired and each re-reads the current state rather than assuming the other has
+ * already happened.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
+import type { PluginApiContract } from '../plugin/plugin-api.cjs';
+import type { PluginSettingsComponentBase } from './plugin-settings-component.cjs';
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * Parameters for the {@link SettingsMigrationComponent} constructor.
+ *
+ * @typeParam TMigratableSettings - The settings this plugin may hand over.
+ */
+export interface SettingsMigrationComponentConstructorParams<TMigratableSettings extends object> {
+    /**
+     * The semver range of contract versions this plugin compiled against, e.g. `'^1'`.
+     *
+     * @remarks
+     * Evaluated by `compare-versions`, which does NOT accept a bare `*`. Spell "any version" as `'>=0.0.0'`.
+     */
+    readonly apiVersionRange: string;
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The contract this plugin expects of the provider, which wins over the provider's own when supplied.
+     *
+     * Worth supplying, and worth keeping NARROW. A migration usually needs one method that has existed since the
+     * provider's first contract version, while the same plugin may read other parts of that API through a much
+     * newer one. Declaring the wider expectation here would refuse to offer the migration to a user on an older
+     * provider — which is precisely the user who still has settings to migrate.
+     */
+    readonly contract?: PluginApiContract;
+    /**
+     * Reads the values currently waiting to be handed over.
+     *
+     * Called afresh on every edge rather than once, so an implementation simply reads its plugin's settings.
+     * Return `null` when there is nothing pending — after a migration has been applied, or on a vault that never
+     * had these settings configured.
+     *
+     * @returns The values to propose, or `null` when there is nothing to offer.
+     */
+    getProposedSettings(this: void): null | TMigratableSettings;
+    /**
+     * The settings component of the plugin making the proposal.
+     *
+     * Taken as a whole component rather than as a bare "ready" flag so the host cannot forget to wire the wait:
+     * whatever {@link getProposedSettings} reads is meaningless until this component has read `data.json`.
+     */
+    readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;
+    /**
+     * The `manifest.id` of the plugin that owns these settings now, as listed in Obsidian's community plugin
+     * registry.
+     */
+    readonly providerPluginId: string;
+    /**
+     * Records that the pending values have been handed over, so the offer is not made again.
+     *
+     * Called ONLY when the user actually applied the migration.
+     *
+     * @returns A {@link Promise} that resolves once the retirement is persisted.
+     *
+     * @remarks
+     * An implementation must PERSIST the retirement — `pluginSettingsComponent.editAndSave(…)`, not
+     * `setProperty(…)`. The latter only edits the in-memory state, so the retirement is forgotten on the next
+     * reload and the migration is offered again forever.
+     */
+    retireProposedSettings(this: void): Promisable<void>;
+    /**
+     * The `manifest.id` of the plugin making the proposal, so the provider's dialog can say whose settings these
+     * are.
+     */
+    readonly sourcePluginId: string;
+}
+/**
+ * Offers settings this plugin used to own to the plugin that owns them now.
+ *
+ * @typeParam TMigratableSettings - The settings this plugin may hand over.
+ */
+export declare class SettingsMigrationComponent<TMigratableSettings extends object> extends ComponentEx {
+    private readonly apiVersionRange;
+    private readonly app;
+    private readonly contract;
+    private readonly getProposedSettings;
+    private isProposing;
+    private readonly pluginSettingsComponent;
+    private readonly providerPluginId;
+    private readonly retireProposedSettings;
+    private readonly sourcePluginId;
+    /**
+     * Creates an instance of {@link SettingsMigrationComponent}.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: SettingsMigrationComponentConstructorParams<TMigratableSettings>);
+    /**
+     * Loads the component, wiring both edges that can make an offer possible.
+     */
+    onload(): void;
+    private handleChange;
+    private propose;
+}

package/dist/lib/cjs/obsidian/html-element.cjs

@@ -142,17 +142,28 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var html_element_exports = {};
 __export(html_element_exports, {
-  appendCodeBlock: () => appendCodeBlock
+  appendCodeBlock: () => appendCodeBlock,
+  applySpellcheckMode: () => applySpellcheckMode
 });
 module.exports = __toCommonJS(html_element_exports);
 var import_css_class = require('./css-class.cjs');
+var import_obsidian_settings = require('./obsidian-settings.cjs');
 function appendCodeBlock(element, code) {
   element.createEl("strong", { cls: `${import_css_class.CssClass.MarkdownRendered} ${import_css_class.CssClass.Code}` }, (strong) => {
     strong.createEl("code", { text: code });
   });
 }
+function applySpellcheckMode(params) {
+  const {
+    app,
+    element,
+    spellcheckMode = import_obsidian_settings.SpellcheckMode.Off
+  } = params;
+  element.setAttribute("spellcheck", String((0, import_obsidian_settings.isSpellcheckEnabledForMode)(app, spellcheckMode)));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  appendCodeBlock
+  appendCodeBlock,
+  applySpellcheckMode
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2h0bWwtZWxlbWVudC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIE9ic2lkaWFuLXNwZWNpZmljIEhUTUwgZWxlbWVudCBoZWxwZXJzLlxuICpcbiAqIFVubGlrZSB0aGUgT2JzaWRpYW4tcnVudGltZS1hZ25vc3RpYyBoZWxwZXJzIGluIGBzcmMvaHRtbC1lbGVtZW50LnRzYCwgdGhlc2UgZGVwZW5kIG9uXG4gKiBPYnNpZGlhbi1zcGVjaWZpYyBwcmVzZW50YXRpb24gXHUyMDE0IGN1cnJlbnRseSB0aGUgYG1hcmtkb3duLXJlbmRlcmVkYCBDU1MgY2xhc3MgdGhhdCBzdHlsZXMgcmVuZGVyZWRcbiAqIG1hcmtkb3duIFx1MjAxNCBzbyB0aGV5IGxpdmUgaW4gdGhlIE9ic2lkaWFuIGxheWVyIGFuZCB1c2UgT2JzaWRpYW4ncyBgY3JlYXRlRWxgIERPTSBhdWdtZW50YXRpb24uXG4gKi9cblxuaW1wb3J0IHsgQ3NzQ2xhc3MgfSBmcm9tICcuL2Nzcy1jbGFzcy50cyc7XG5cbi8qKlxuICogQXBwZW5kcyBhIGNvZGUgYmxvY2sgdG8gdGhlIGdpdmVuIERvY3VtZW50RnJhZ21lbnQgb3IgSFRNTEVsZW1lbnQsIHN0eWxlZCB0byBtYXRjaCBPYnNpZGlhbidzXG4gKiByZW5kZXJlZC1tYXJrZG93biBpbmxpbmUgY29kZS5cbiAqXG4gKiBAcGFyYW0gZWxlbWVudCAtIFRoZSBEb2N1bWVudEZyYWdtZW50IG9yIEhUTUxFbGVtZW50IHRvIGFwcGVuZCB0aGUgY29kZSBibG9jayB0by5cbiAqIEBwYXJhbSBjb2RlIC0gVGhlIGNvZGUgdG8gYmUgZGlzcGxheWVkIGluIHRoZSBjb2RlIGJsb2NrLlxuICovXG5leHBvcnQgZnVuY3Rpb24gYXBwZW5kQ29kZUJsb2NrKGVsZW1lbnQ6IERvY3VtZW50RnJhZ21lbnQgfCBIVE1MRWxlbWVudCwgY29kZTogc3RyaW5nKTogdm9pZCB7XG4gIGVsZW1lbnQuY3JlYXRlRWwoJ3N0cm9uZycsIHsgY2xzOiBgJHtDc3NDbGFzcy5NYXJrZG93blJlbmRlcmVkfSAke0Nzc0NsYXNzLkNvZGV9YCB9LCAoc3Ryb25nKSA9PiB7XG4gICAgc3Ryb25nLmNyZWF0ZUVsKCdjb2RlJywgeyB0ZXh0OiBjb2RlIH0pO1xuICB9KTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBVUEsdUJBQXlCO0FBU2xCLFNBQVMsZ0JBQWdCLFNBQXlDLE1BQW9CO0FBQzNGLFVBQVEsU0FBUyxVQUFVLEVBQUUsS0FBSyxHQUFHLDBCQUFTLGdCQUFnQixJQUFJLDBCQUFTLElBQUksR0FBRyxHQUFHLENBQUMsV0FBVztBQUMvRixXQUFPLFNBQVMsUUFBUSxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBQUEsRUFDeEMsQ0FBQztBQUNIOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/html-element.d.cts

@@ -5,9 +5,31 @@
  * Obsidian-specific HTML element helpers.
  *
  * Unlike the Obsidian-runtime-agnostic helpers in `src/html-element.ts`, these depend on
- * Obsidian-specific presentation — currently the `markdown-rendered` CSS class that styles rendered
- * markdown — so they live in the Obsidian layer and use Obsidian's `createEl` DOM augmentation.
+ * Obsidian-specific presentation — the `markdown-rendered` CSS class that styles rendered markdown, and
+ * the `Editor > Spellcheck` vault setting — so they live in the Obsidian layer and use Obsidian's
+ * `createEl` DOM augmentation.
  */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import { SpellcheckMode } from './obsidian-settings.cjs';
+/**
+ * Options for {@link applySpellcheckMode}.
+ */
+export interface ApplySpellcheckModeParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The element to set the `spellcheck` attribute on.
+     */
+    readonly element: HTMLElement;
+    /**
+     * The mode deciding whether the element is spell-checked.
+     *
+     * @default `SpellcheckMode.Off`
+     */
+    readonly spellcheckMode?: SpellcheckMode;
+}
 /**
  * Appends a code block to the given DocumentFragment or HTMLElement, styled to match Obsidian's
  * rendered-markdown inline code.
@@ -16,3 +38,25 @@
  * @param code - The code to be displayed in the code block.
  */
 export declare function appendCodeBlock(element: DocumentFragment | HTMLElement, code: string): void;
+/**
+ * Sets the `spellcheck` attribute on an element from a {@link SpellcheckMode}.
+ *
+ * The attribute has to be set explicitly, because both of the surfaces that need this are born with
+ * `spellcheck="false"`: `AbstractTextComponent` forces it onto every text component, and Obsidian builds
+ * every `SuggestModal` input with it without consulting `Editor > Spellcheck` at all.
+ *
+ * Which of those a given box wants is a call-site decision, and the distinction that holds up is what the
+ * box is FOR: one that only FINDS something is a search field and stays unchecked, because squiggles under
+ * half-typed fragments are noise; one that NAMES something is a prose field and follows the setting, the
+ * way Obsidian's own inline title and file-explorer rename do.
+ *
+ * Call it again whenever that answer changes — a picker that switches between finding and creating flips
+ * modes mid-open, and the attribute has to follow.
+ *
+ * The name being typed may be a PATH rather than a bare basename, so folder segments get checked too.
+ * That is what Obsidian's own inline rename does, and the alternative — checking only the last segment —
+ * cannot be expressed as an attribute.
+ *
+ * @param params - The parameters for applying the spellcheck mode.
+ */
+export declare function applySpellcheckMode(params: ApplySpellcheckModeParams): void;