@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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

@@ -0,0 +1,246 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // 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
+    }
+  );
+
+  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('@mnaoumov/typescript-lib/async');
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+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/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 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 { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\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 { 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  readonly getProposedSettings: () => 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  readonly retireProposedSettings: () => 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;AAuBA,mBAAkC;AAClC,0BAA4C;AAU5C,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/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 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.
+     */
+    readonly getProposedSettings: () => 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.
+     */
+    readonly retireProposedSettings: () => 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;
+}