obsidian-dev-utils 101.5.0 → 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/mobile-trusted-input.cjs

@@ -192,4 +192,4 @@ function getSeamFunction(name) {
   typeIntoEditor,
   unhoverElement
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/mobile-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone \u2014\n * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted \u2014 so the injection\n * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's\n * binding channel, and the host injects it into the WebView over CDP.\n *\n * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the\n * harness rather than reimplementing the wire format: they call\n * `window.__obsidianIntegrationTesting.trustedInput.*`, which holds the very function objects the harness\n * seeds into an `evalInObsidian` closure's `lib` bag. Delegating is what keeps the mobile semantics \u2014\n * tap, long-press for `button: 'right'`, a throw for `'middle'`, the `pressKey` key set, and the throws\n * for the `:hover` helpers \u2014 identical to the harness's own copy for free, instead of a second\n * implementation to hand-sync (see the project `AGENTS.md` **L4**).\n *\n * The namespace shape is declared **locally**: the harness must never be a dependency of this library, in\n * either direction, at runtime or in types.\n *\n * **Consequence, and it is deliberate:** these helpers only work inside an app the harness bootstrapped.\n * Outside one they throw a message saying so, rather than silently doing nothing \u2014 a no-op would recreate\n * exactly the false-confidence failure trusted input exists to end. Consumers wanting the platform-correct\n * helper should import the {@link ../trusted-input.ts | trusted-input} facade instead of this module.\n */\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n  // The parameter contracts live with the desktop twin and are shared verbatim, so the two platforms\n  // Cannot drift apart on what a caller passes. A type-only import loads nothing (L5).\n} from './desktop-trusted-input.ts';\n\n/**\n * The global the harness bootstraps its namespace onto.\n */\ninterface ObsidianIntegrationTestingHolder {\n  __obsidianIntegrationTesting: ObsidianIntegrationTestingNamespace;\n}\n\n/**\n * The part of the harness namespace this module reads. Everything else on it is none of this module's\n * business.\n */\ninterface ObsidianIntegrationTestingNamespace {\n  trustedInput?: Partial<TrustedInputSeam>;\n}\n\n/**\n * The trusted-input seam the `obsidian-integration-testing` harness publishes on its namespace.\n *\n * Declared here rather than imported: the harness is not a dependency of this library. It mirrors\n * `namespace-bootstrap.ts`'s `trustedInput` object, and the mirroring is by hand \u2014 the same\n * behavioral-sync obligation the desktop twin carries.\n */\ninterface TrustedInputSeam {\n  clickElement(params: ClickElementParams): Promise<void>;\n  clickMouse(params: ClickMouseParams): Promise<void>;\n  hoverElement(params: HoverElementParams): Promise<void>;\n  moveMouse(params: MoveMouseParams): Promise<void>;\n  pressKey(params: PressKeyParams): Promise<void>;\n  typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;\n  unhoverElement(params: UnhoverElementParams): Promise<void>;\n}\n\n/**\n * Clicks the center of an element using **trusted** touch input \u2014 a CDP tap in the WebView, injected by\n * the host.\n *\n * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens\n * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing\n * one would be worse than saying so.\n *\n * @param params - The element to click, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickElement(params: ClickElementParams): Promise<void> {\n  await getSeamFunction('clickElement')(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** touch input, injected by the host over CDP.\n *\n * The coordinates are CSS pixels in the WebView's own viewport \u2014 which is what CDP takes \u2014 so\n * `devicePixelRatio` never enters the picture.\n *\n * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  await getSeamFunction('clickMouse')(params);\n}\n\n/**\n * Always throws: `:hover` has no touch equivalent.\n *\n * A silent no-op here would let a hover test pass on a phone without hovering anything, so the mobile arm\n * refuses instead. Gate the assertion on `Platform.isDesktopApp`, or drive the element with\n * {@link clickElement}.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  await getSeamFunction('hoverElement')(params);\n}\n\n/**\n * Always throws: a touch screen has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  await getSeamFunction('moveMouse')(params);\n}\n\n/**\n * Presses a single key using **trusted** keyboard input, injected by the host over CDP.\n *\n * Named keys (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single printable\n * characters are supported; anything else throws rather than pressing nothing.\n *\n * @param params - The key to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the key press has been injected.\n */\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  await getSeamFunction('pressKey')(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input, injected by the host over CDP.\n *\n * Focuses the editor (caret to the end), presses every code point of the text, then polls until the\n * document reflects the input or a bounded timeout elapses.\n *\n * @param params - The editor to type into and the text to type.\n * @returns A {@link Promise} that resolves once the keystrokes have settled.\n */\nexport async function typeIntoEditor(params: TypeIntoEditorParams): Promise<void> {\n  await getSeamFunction('typeIntoEditor')(params);\n}\n\n/**\n * Always throws, for the same reason as {@link hoverElement}: there is no `:hover` state to clear.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  await getSeamFunction('unhoverElement')(params);\n}\n\nfunction getSeamFunction<Key extends keyof TrustedInputSeam>(name: Key): TrustedInputSeam[Key] {\n  // eslint-disable-next-line obsidianmd/no-global-this -- The harness installs its namespace on the realm global; there is nowhere else to read it from.\n  const holder = globalThis as Partial<ObsidianIntegrationTestingHolder>;\n  const seamFunction = holder.__obsidianIntegrationTesting?.trustedInput?.[name];\n  if (!seamFunction) {\n    throw new Error(\n      `Trusted input is unavailable on mobile: \\`window.__obsidianIntegrationTesting.trustedInput.${name}\\` is not installed. `\n        + 'A phone has no in-renderer route to a trusted event, so the injection is a round-trip to the host over the '\n        + '`obsidian-integration-testing` Appium transport\\'s channel \u2014 which means these helpers only work inside an app that '\n        + 'harness bootstrapped.'\n    );\n  }\n\n  return seamFunction;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgFA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAWA,eAAsB,WAAW,QAAyC;AACxE,QAAM,gBAAgB,YAAY,EAAE,MAAM;AAC5C;AAYA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAQA,eAAsB,UAAU,QAAwC;AACtE,QAAM,gBAAgB,WAAW,EAAE,MAAM;AAC3C;AAWA,eAAsB,SAAS,QAAuC;AACpE,QAAM,gBAAgB,UAAU,EAAE,MAAM;AAC1C;AAWA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAQA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAEA,SAAS,gBAAoD,MAAkC;AAE7F,QAAM,SAAS;AACf,QAAM,eAAe,OAAO,8BAA8B,eAAe,IAAI;AAC7E,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI;AAAA,MACR,8FAA8F,IAAI;AAAA,IAIpG;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/mobile-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone \u2014\n * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted \u2014 so the injection\n * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's\n * binding channel, and the host injects it into the WebView over CDP \u2014 as `Input.dispatchTouchEvent` for\n * a tap but `Input.synthesizeTapGesture` for a long-press, because `dispatchTouchEvent` injects past\n * Android's gesture recognizer and so is classified as a tap at any dwell.\n *\n * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the\n * harness rather than reimplementing the wire format: they call\n * `window.__obsidianIntegrationTesting.trustedInput.*`, which holds the very function objects the harness\n * seeds into an `evalInObsidian` closure's `lib` bag. Delegating is what keeps the mobile semantics \u2014\n * tap, long-press for `button: 'right'`, a throw for `'middle'`, the `pressKey` key set, and the throws\n * for the `:hover` helpers \u2014 identical to the harness's own copy for free, instead of a second\n * implementation to hand-sync (see the project `AGENTS.md` **L4**).\n *\n * The namespace shape is declared **locally**: the harness must never be a dependency of this library, in\n * either direction, at runtime or in types.\n *\n * **Consequence, and it is deliberate:** these helpers only work inside an app the harness bootstrapped.\n * Outside one they throw a message saying so, rather than silently doing nothing \u2014 a no-op would recreate\n * exactly the false-confidence failure trusted input exists to end. Consumers wanting the platform-correct\n * helper should import the {@link ../trusted-input.ts | trusted-input} facade instead of this module.\n */\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n  // The parameter contracts live with the desktop twin and are shared verbatim, so the two platforms\n  // Cannot drift apart on what a caller passes. A type-only import loads nothing (L5).\n} from './desktop-trusted-input.ts';\n\n/**\n * The global the harness bootstraps its namespace onto.\n */\ninterface ObsidianIntegrationTestingHolder {\n  __obsidianIntegrationTesting: ObsidianIntegrationTestingNamespace;\n}\n\n/**\n * The part of the harness namespace this module reads. Everything else on it is none of this module's\n * business.\n */\ninterface ObsidianIntegrationTestingNamespace {\n  trustedInput?: Partial<TrustedInputSeam>;\n}\n\n/**\n * The trusted-input seam the `obsidian-integration-testing` harness publishes on its namespace.\n *\n * Declared here rather than imported: the harness is not a dependency of this library. It mirrors\n * `namespace-bootstrap.ts`'s `trustedInput` object, and the mirroring is by hand \u2014 the same\n * behavioral-sync obligation the desktop twin carries.\n */\ninterface TrustedInputSeam {\n  clickElement(params: ClickElementParams): Promise<void>;\n  clickMouse(params: ClickMouseParams): Promise<void>;\n  hoverElement(params: HoverElementParams): Promise<void>;\n  moveMouse(params: MoveMouseParams): Promise<void>;\n  pressKey(params: PressKeyParams): Promise<void>;\n  typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;\n  unhoverElement(params: UnhoverElementParams): Promise<void>;\n}\n\n/**\n * Clicks the center of an element using **trusted** touch input, injected into the WebView by the host\n * over CDP.\n *\n * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens\n * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing\n * one would be worse than saying so.\n *\n * @param params - The element to click, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickElement(params: ClickElementParams): Promise<void> {\n  await getSeamFunction('clickElement')(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** touch input, injected by the host over CDP.\n *\n * The coordinates are CSS pixels in the WebView's own viewport \u2014 which is what CDP takes \u2014 so\n * `devicePixelRatio` never enters the picture.\n *\n * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  await getSeamFunction('clickMouse')(params);\n}\n\n/**\n * Always throws: `:hover` has no touch equivalent.\n *\n * A silent no-op here would let a hover test pass on a phone without hovering anything, so the mobile arm\n * refuses instead. Gate the assertion on `Platform.isDesktopApp`, or drive the element with\n * {@link clickElement}.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  await getSeamFunction('hoverElement')(params);\n}\n\n/**\n * Always throws: a touch screen has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  await getSeamFunction('moveMouse')(params);\n}\n\n/**\n * Presses a single key using **trusted** keyboard input, injected by the host over CDP.\n *\n * Named keys (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single printable\n * characters are supported; anything else throws rather than pressing nothing.\n *\n * @param params - The key to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the key press has been injected.\n */\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  await getSeamFunction('pressKey')(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input, injected by the host over CDP.\n *\n * Focuses the editor (caret to the end), presses every code point of the text, then polls until the\n * document reflects the input or a bounded timeout elapses.\n *\n * @param params - The editor to type into and the text to type.\n * @returns A {@link Promise} that resolves once the keystrokes have settled.\n */\nexport async function typeIntoEditor(params: TypeIntoEditorParams): Promise<void> {\n  await getSeamFunction('typeIntoEditor')(params);\n}\n\n/**\n * Always throws, for the same reason as {@link hoverElement}: there is no `:hover` state to clear.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  await getSeamFunction('unhoverElement')(params);\n}\n\nfunction getSeamFunction<Key extends keyof TrustedInputSeam>(name: Key): TrustedInputSeam[Key] {\n  // eslint-disable-next-line obsidianmd/no-global-this -- The harness installs its namespace on the realm global; there is nowhere else to read it from.\n  const holder = globalThis as Partial<ObsidianIntegrationTestingHolder>;\n  const seamFunction = holder.__obsidianIntegrationTesting?.trustedInput?.[name];\n  if (!seamFunction) {\n    throw new Error(\n      `Trusted input is unavailable on mobile: \\`window.__obsidianIntegrationTesting.trustedInput.${name}\\` is not installed. `\n        + 'A phone has no in-renderer route to a trusted event, so the injection is a round-trip to the host over the '\n        + '`obsidian-integration-testing` Appium transport\\'s channel \u2014 which means these helpers only work inside an app that '\n        + 'harness bootstrapped.'\n    );\n  }\n\n  return seamFunction;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkFA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAWA,eAAsB,WAAW,QAAyC;AACxE,QAAM,gBAAgB,YAAY,EAAE,MAAM;AAC5C;AAYA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAQA,eAAsB,UAAU,QAAwC;AACtE,QAAM,gBAAgB,WAAW,EAAE,MAAM;AAC3C;AAWA,eAAsB,SAAS,QAAuC;AACpE,QAAM,gBAAgB,UAAU,EAAE,MAAM;AAC1C;AAWA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAQA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAEA,SAAS,gBAAoD,MAAkC;AAE7F,QAAM,SAAS;AACf,QAAM,eAAe,OAAO,8BAA8B,eAAe,IAAI;AAC7E,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI;AAAA,MACR,8FAA8F,IAAI;AAAA,IAIpG;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/cjs/obsidian/mobile-trusted-input.d.cts

@@ -5,7 +5,9 @@
  * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone —
  * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted — so the injection
  * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's
- * binding channel, and the host injects it into the WebView over CDP.
+ * binding channel, and the host injects it into the WebView over CDP — as `Input.dispatchTouchEvent` for
+ * a tap but `Input.synthesizeTapGesture` for a long-press, because `dispatchTouchEvent` injects past
+ * Android's gesture recognizer and so is classified as a tap at any dwell.
  *
  * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the
  * harness rather than reimplementing the wire format: they call
@@ -25,8 +27,8 @@
  */
 import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.cjs';
 /**
- * Clicks the center of an element using **trusted** touch input — a CDP tap in the WebView, injected by
- * the host.
+ * Clicks the center of an element using **trusted** touch input, injected into the WebView by the host
+ * over CDP.
  *
  * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens
  * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing

package/dist/lib/cjs/obsidian/plugin/index.cjs

@@ -157,7 +157,8 @@ __export(plugin_exports, {
   "plugin-api": () => plugin_api,
   "plugin-context": () => plugin_context,
   "plugin-event-source": () => plugin_event_source,
-  "plugin-settings-tab": () => plugin_settings_tab
+  "plugin-settings-tab": () => plugin_settings_tab,
+  "settings-migration-api": () => settings_migration_api
 });
 module.exports = __toCommonJS(plugin_exports);
 var obsidian_plugin_repo_paths = __toESM(__extractDefault(require('./obsidian-plugin-repo-paths.cjs')), 1);
@@ -166,6 +167,7 @@ var plugin_context = __toESM(__extractDefault(require('./plugin-context.cjs')),
 var plugin_event_source = __toESM(__extractDefault(require('./plugin-event-source.cjs')), 1);
 var plugin_settings_tab = __toESM(__extractDefault(require('./plugin-settings-tab.cjs')), 1);
 var plugin = __toESM(__extractDefault(require('./plugin.cjs')), 1);
+var settings_migration_api = __toESM(__extractDefault(require('./settings-migration-api.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   "obsidian-plugin-repo-paths": null,
@@ -173,6 +175,7 @@ var plugin = __toESM(__extractDefault(require('./plugin.cjs')), 1);
   "plugin-api": null,
   "plugin-context": null,
   "plugin-event-source": null,
-  "plugin-settings-tab": null
+  "plugin-settings-tab": null,
+  "settings-migration-api": null
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3BsdWdpbi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdvYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocycgZnJvbSAnLi9vYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocy50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWFwaScgZnJvbSAnLi9wbHVnaW4tYXBpLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tc2V0dGluZ3MtdGFiJyBmcm9tICcuL3BsdWdpbi1zZXR0aW5ncy10YWIudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbicgZnJvbSAnLi9wbHVnaW4udHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUEsc0NBQUFBO0FBQUEsRUFBQTtBQUFBLHNCQUFBQztBQUFBLEVBQUEsd0JBQUFDO0FBQUEsRUFBQSw2QkFBQUM7QUFBQSxFQUFBLDZCQUFBQztBQUFBO0FBQUE7QUFFQSxJQUFBSiw2QkFBOEM7QUFDOUMsSUFBQUMsYUFBOEI7QUFDOUIsSUFBQUMsaUJBQWtDO0FBQ2xDLElBQUFDLHNCQUF1QztBQUN2QyxJQUFBQyxzQkFBdUM7QUFDdkMsYUFBMEI7IiwKICAibmFtZXMiOiBbIm9ic2lkaWFuLXBsdWdpbi1yZXBvLXBhdGhzIiwgInBsdWdpbi1hcGkiLCAicGx1Z2luLWNvbnRleHQiLCAicGx1Z2luLWV2ZW50LXNvdXJjZSIsICJwbHVnaW4tc2V0dGluZ3MtdGFiIl0KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3BsdWdpbi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdvYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocycgZnJvbSAnLi9vYnNpZGlhbi1wbHVnaW4tcmVwby1wYXRocy50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWFwaScgZnJvbSAnLi9wbHVnaW4tYXBpLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tc2V0dGluZ3MtdGFiJyBmcm9tICcuL3BsdWdpbi1zZXR0aW5ncy10YWIudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbicgZnJvbSAnLi9wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ3NldHRpbmdzLW1pZ3JhdGlvbi1hcGknIGZyb20gJy4vc2V0dGluZ3MtbWlncmF0aW9uLWFwaS50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQSxzQ0FBQUE7QUFBQSxFQUFBO0FBQUEsc0JBQUFDO0FBQUEsRUFBQSx3QkFBQUM7QUFBQSxFQUFBLDZCQUFBQztBQUFBLEVBQUEsNkJBQUFDO0FBQUEsRUFBQSxnQ0FBQUM7QUFBQTtBQUFBO0FBRUEsSUFBQUwsNkJBQThDO0FBQzlDLElBQUFDLGFBQThCO0FBQzlCLElBQUFDLGlCQUFrQztBQUNsQyxJQUFBQyxzQkFBdUM7QUFDdkMsSUFBQUMsc0JBQXVDO0FBQ3ZDLGFBQTBCO0FBQzFCLElBQUFDLHlCQUEwQzsiLAogICJuYW1lcyI6IFsib2JzaWRpYW4tcGx1Z2luLXJlcG8tcGF0aHMiLCAicGx1Z2luLWFwaSIsICJwbHVnaW4tY29udGV4dCIsICJwbHVnaW4tZXZlbnQtc291cmNlIiwgInBsdWdpbi1zZXR0aW5ncy10YWIiLCAic2V0dGluZ3MtbWlncmF0aW9uLWFwaSJdCn0K

package/dist/lib/cjs/obsidian/plugin/index.d.cts

@@ -5,3 +5,4 @@ export * as 'plugin-context' from './plugin-context.cjs';
 export * as 'plugin-event-source' from './plugin-event-source.cjs';
 export * as 'plugin-settings-tab' from './plugin-settings-tab.cjs';
 export * as 'plugin' from './plugin.cjs';
+export * as 'settings-migration-api' from './settings-migration-api.cjs';

package/dist/lib/cjs/obsidian/plugin/settings-migration-api.cjs

@@ -0,0 +1,141 @@
+/*
+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 __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_api_exports = {};
+module.exports = __toCommonJS(settings_migration_api_exports);
+//# sourceMappingURL=data:application/json;base64,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