@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/components/rmdir-guard-component.d.mts

@@ -0,0 +1,76 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Contains class {@link RmdirGuardComponent} that makes the `recursive` flag of
+ * {@link https://docs.obsidian.md/Reference/TypeScript+API/DataAdapter/rmdir | DataAdapter.rmdir} mean what it says.
+ */
+import type { App } from 'obsidian';
+import { MonkeyAroundComponent } from './monkey-around-component.mjs';
+/**
+ * The `code` carried by the error thrown when a non-recursive `rmdir` is refused because the folder has children.
+ *
+ * Matches the POSIX/Node error code a correct non-recursive directory removal produces, so a caller already
+ * branching on `error.code` keeps working. Check the `code`, never `instanceof` — every plugin bundles its own
+ * copy of this library, so the error may cross a copy boundary.
+ */
+export declare const NOT_EMPTY_DIRECTORY_ERROR_CODE = "ENOTEMPTY";
+/**
+ * Makes `app.vault.adapter.rmdir(path, false)` behave as its name promises: a non-recursive call on a folder
+ * that still has children throws instead of deleting them.
+ *
+ * @remarks
+ * Obsidian's adapters do not honor `recursive: false`, and they get it wrong in opposite directions:
+ *
+ * - `CapacitorAdapter` (mobile) does not accept the argument at all — it always removes recursively, so a
+ *   non-recursive call silently deletes the folder and everything under it. This is the data-loss footgun.
+ * - `FileSystemAdapter` (desktop) forwards it to `fs.promises.rm(path, { recursive })`, which throws
+ *   `ERR_FS_EISDIR` for *any* directory when `recursive` is `false` — so the non-recursive call never
+ *   succeeds, not even on an empty folder.
+ *
+ * While loaded, this component gives both platforms the same, correct behavior: a non-empty folder is
+ * refused with an {@link NOT_EMPTY_DIRECTORY_ERROR_CODE} error and nothing is deleted; an empty folder is
+ * removed. Emptiness is decided from the adapter (via {@link isEmptyFolder}), not from the vault index — the
+ * index omits dot-prefixed and otherwise hidden entries, so a folder holding only hidden files reads as empty
+ * there and the guard would wave through exactly the deletion it exists to prevent.
+ *
+ * A folder proven empty is removed by forwarding to the original method with `recursive: true`. That is not
+ * merely defensive: it is what makes the empty-folder case succeed on desktop, where the non-recursive call
+ * would otherwise throw.
+ *
+ * Calls that already pass `recursive: true`, and calls whose target is not a folder (a file, a missing path),
+ * are passed through untouched and keep their native behavior.
+ *
+ * Loading the guard more than once is safe, and it deliberately carries **no patch token**. Every plugin
+ * bundles its own copy of this library and they all patch the one shared adapter, so several guards do stack
+ * — but the operation is idempotent (prove empty, then delete), so stacking changes nothing: the outermost
+ * guard either throws or forwards with `recursive: true`, which every guard beneath passes straight through.
+ * They can also be unloaded in any order and the method stays guarded until the last one goes, because
+ * `monkey-around` neutralizes an unloaded wrapper in place rather than splicing it out. A token would only
+ * move the decision to the innermost guard — an equally arbitrary choice — while adding a path on which a
+ * guard declines to guard. For a data-loss guard that trade is not worth making. Contrast
+ * `RenameDeleteHandlerComponent`, which does need one: suppressing `runAsyncLinkUpdate` is not idempotent,
+ * so two of those would conflict.
+ *
+ * This component is deliberately **opt-in**: `app.vault.adapter` is shared by the whole app, so a library that
+ * installed this patch on its own would change `rmdir` semantics for every other plugin, including the ones
+ * that never asked for it. A plugin that deletes folders opts in for itself:
+ *
+ * @example
+ * ```ts
+ * this.addChild(new RmdirGuardComponent(this.app));
+ * ```
+ */
+export declare class RmdirGuardComponent extends MonkeyAroundComponent {
+    protected readonly app: App;
+    /**
+     * Creates a new instance of the {@link RmdirGuardComponent} class.
+     *
+     * @param app - The Obsidian app instance whose vault adapter to guard.
+     */
+    constructor(app: App);
+    /**
+     * Installs the `rmdir` guard. The patch is uninstalled when this component unloads.
+     */
+    onload(): void;
+}

package/dist/lib/esm/components/rmdir-guard-component.mjs

@@ -0,0 +1,100 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { isEmptyFolder } from "../vault.mjs";
+import { MonkeyAroundComponent } from "./monkey-around-component.mjs";
+const NOT_EMPTY_DIRECTORY_ERROR_CODE = "ENOTEMPTY";
+class RmdirGuardComponent extends MonkeyAroundComponent {
+  /**
+   * Creates a new instance of the {@link RmdirGuardComponent} class.
+   *
+   * @param app - The Obsidian app instance whose vault adapter to guard.
+   */
+  constructor(app) {
+    super();
+    this.app = app;
+  }
+  app;
+  /**
+   * Installs the `rmdir` guard. The patch is uninstalled when this component unloads.
+   */
+  onload() {
+    this.registerMethodPatch({
+      $object: this.app.vault.adapter,
+      methodName: "rmdir",
+      patchHandler: async ({
+        fallback,
+        originalArguments: [normalizedPath, recursive],
+        originalMethodBound
+      }) => {
+        if (recursive) {
+          await fallback();
+          return;
+        }
+        const stats = await this.app.vault.adapter.stat(normalizedPath);
+        if (stats?.type !== "folder") {
+          await fallback();
+          return;
+        }
+        if (!await isEmptyFolder(this.app, normalizedPath)) {
+          throw Object.assign(new Error(`Directory ${normalizedPath} is not empty`), {
+            code: NOT_EMPTY_DIRECTORY_ERROR_CODE,
+            path: normalizedPath
+          });
+        }
+        await originalMethodBound(normalizedPath, true);
+      }
+    });
+  }
+}
+export {
+  NOT_EMPTY_DIRECTORY_ERROR_CODE,
+  RmdirGuardComponent
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/components/rmdir-guard-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains class {@link RmdirGuardComponent} that makes the `recursive` flag of\n * {@link https://docs.obsidian.md/Reference/TypeScript+API/DataAdapter/rmdir | DataAdapter.rmdir} mean what it says.\n */\n\nimport type { App } from 'obsidian';\n\nimport { isEmptyFolder } from '../vault.ts';\nimport { MonkeyAroundComponent } from './monkey-around-component.ts';\n\n/**\n * The `code` carried by the error thrown when a non-recursive `rmdir` is refused because the folder has children.\n *\n * Matches the POSIX/Node error code a correct non-recursive directory removal produces, so a caller already\n * branching on `error.code` keeps working. Check the `code`, never `instanceof` \u2014 every plugin bundles its own\n * copy of this library, so the error may cross a copy boundary.\n */\nexport const NOT_EMPTY_DIRECTORY_ERROR_CODE = 'ENOTEMPTY';\n\n/**\n * Makes `app.vault.adapter.rmdir(path, false)` behave as its name promises: a non-recursive call on a folder\n * that still has children throws instead of deleting them.\n *\n * @remarks\n * Obsidian's adapters do not honor `recursive: false`, and they get it wrong in opposite directions:\n *\n * - `CapacitorAdapter` (mobile) does not accept the argument at all \u2014 it always removes recursively, so a\n *   non-recursive call silently deletes the folder and everything under it. This is the data-loss footgun.\n * - `FileSystemAdapter` (desktop) forwards it to `fs.promises.rm(path, { recursive })`, which throws\n *   `ERR_FS_EISDIR` for *any* directory when `recursive` is `false` \u2014 so the non-recursive call never\n *   succeeds, not even on an empty folder.\n *\n * While loaded, this component gives both platforms the same, correct behavior: a non-empty folder is\n * refused with an {@link NOT_EMPTY_DIRECTORY_ERROR_CODE} error and nothing is deleted; an empty folder is\n * removed. Emptiness is decided from the adapter (via {@link isEmptyFolder}), not from the vault index \u2014 the\n * index omits dot-prefixed and otherwise hidden entries, so a folder holding only hidden files reads as empty\n * there and the guard would wave through exactly the deletion it exists to prevent.\n *\n * A folder proven empty is removed by forwarding to the original method with `recursive: true`. That is not\n * merely defensive: it is what makes the empty-folder case succeed on desktop, where the non-recursive call\n * would otherwise throw.\n *\n * Calls that already pass `recursive: true`, and calls whose target is not a folder (a file, a missing path),\n * are passed through untouched and keep their native behavior.\n *\n * Loading the guard more than once is safe, and it deliberately carries **no patch token**. Every plugin\n * bundles its own copy of this library and they all patch the one shared adapter, so several guards do stack\n * \u2014 but the operation is idempotent (prove empty, then delete), so stacking changes nothing: the outermost\n * guard either throws or forwards with `recursive: true`, which every guard beneath passes straight through.\n * They can also be unloaded in any order and the method stays guarded until the last one goes, because\n * `monkey-around` neutralizes an unloaded wrapper in place rather than splicing it out. A token would only\n * move the decision to the innermost guard \u2014 an equally arbitrary choice \u2014 while adding a path on which a\n * guard declines to guard. For a data-loss guard that trade is not worth making. Contrast\n * `RenameDeleteHandlerComponent`, which does need one: suppressing `runAsyncLinkUpdate` is not idempotent,\n * so two of those would conflict.\n *\n * This component is deliberately **opt-in**: `app.vault.adapter` is shared by the whole app, so a library that\n * installed this patch on its own would change `rmdir` semantics for every other plugin, including the ones\n * that never asked for it. A plugin that deletes folders opts in for itself:\n *\n * @example\n * ```ts\n * this.addChild(new RmdirGuardComponent(this.app));\n * ```\n */\nexport class RmdirGuardComponent extends MonkeyAroundComponent {\n  /**\n   * Creates a new instance of the {@link RmdirGuardComponent} class.\n   *\n   * @param app - The Obsidian app instance whose vault adapter to guard.\n   */\n  public constructor(protected readonly app: App) {\n    super();\n  }\n\n  /**\n   * Installs the `rmdir` guard. The patch is uninstalled when this component unloads.\n   */\n  public override onload(): void {\n    this.registerMethodPatch({\n      $object: this.app.vault.adapter,\n      methodName: 'rmdir',\n      patchHandler: async ({\n        fallback,\n        originalArguments: [normalizedPath, recursive],\n        originalMethodBound\n      }) => {\n        if (recursive) {\n          await fallback();\n          return;\n        }\n\n        const stats = await this.app.vault.adapter.stat(normalizedPath);\n        if (stats?.type !== 'folder') {\n          await fallback();\n          return;\n        }\n\n        if (!await isEmptyFolder(this.app, normalizedPath)) {\n          throw Object.assign(new Error(`Directory ${normalizedPath} is not empty`), {\n            code: NOT_EMPTY_DIRECTORY_ERROR_CODE,\n            path: normalizedPath\n          });\n        }\n\n        // The folder is proven empty, so a recursive removal is equivalent -- and, unlike the non-recursive\n        // one, it actually works on the desktop adapter.\n        await originalMethodBound(normalizedPath, true);\n      }\n    });\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,SAAS,qBAAqB;AAC9B,SAAS,6BAA6B;AAS/B,MAAM,iCAAiC;AAgDvC,MAAM,4BAA4B,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMtD,YAA+B,KAAU;AAC9C,UAAM;AAD8B;AAAA,EAEtC;AAAA,EAFsC;AAAA;AAAA;AAAA;AAAA,EAOtB,SAAe;AAC7B,SAAK,oBAAoB;AAAA,MACvB,SAAS,KAAK,IAAI,MAAM;AAAA,MACxB,YAAY;AAAA,MACZ,cAAc,OAAO;AAAA,QACnB;AAAA,QACA,mBAAmB,CAAC,gBAAgB,SAAS;AAAA,QAC7C;AAAA,MACF,MAAM;AACJ,YAAI,WAAW;AACb,gBAAM,SAAS;AACf;AAAA,QACF;AAEA,cAAM,QAAQ,MAAM,KAAK,IAAI,MAAM,QAAQ,KAAK,cAAc;AAC9D,YAAI,OAAO,SAAS,UAAU;AAC5B,gBAAM,SAAS;AACf;AAAA,QACF;AAEA,YAAI,CAAC,MAAM,cAAc,KAAK,KAAK,cAAc,GAAG;AAClD,gBAAM,OAAO,OAAO,IAAI,MAAM,aAAa,cAAc,eAAe,GAAG;AAAA,YACzE,MAAM;AAAA,YACN,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAIA,cAAM,oBAAoB,gBAAgB,IAAI;AAAA,MAChD;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
  "names": []
}


package/dist/lib/esm/components/settings-migration-component.d.mts

@@ -0,0 +1,120 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @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';
+import type { Promisable } from 'type-fest';
+import type { PluginApiContract } from '../plugin/plugin-api.mjs';
+import type { PluginSettingsComponentBase } from './plugin-settings-component.mjs';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * 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;
+}

package/dist/lib/esm/components/settings-migration-component.mjs

@@ -0,0 +1,133 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { invokeAsyncSafely } from "@mnaoumov/typescript-lib/async";
+import { normalizeOptionalProperties } from "@mnaoumov/typescript-lib/object-utils";
+import { watchPluginApi } from "../plugin/plugin-api.mjs";
+import { registerAsyncEvent } from "./async-events-component.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+class SettingsMigrationComponent extends 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 = watchPluginApi(normalizeOptionalProperties({
+      apiVersionRange: this.apiVersionRange,
+      app: this.app,
+      component: this,
+      contract: this.contract,
+      pluginId: this.providerPluginId
+    }));
+    registerAsyncEvent(
+      this,
+      ref.on("change", () => {
+        this.handleChange(ref);
+      })
+    );
+    registerAsyncEvent(
+      this,
+      this.pluginSettingsComponent.on("loadSettings", () => {
+        this.handleChange(ref);
+      })
+    );
+    this.handleChange(ref);
+  }
+  handleChange(ref) {
+    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;
+    }
+  }
+}
+export {
+  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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAS,yBAAyB;AAClC,SAAS,mCAAmC;AAU5C,SAAS,sBAAsB;AAC/B,SAAS,0BAA0B;AACnC,SAAS,mBAAmB;AAkFrB,MAAM,mCAAuE,YAAY;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,MAAM,eAA0D,4BAAkD;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,sBAAkB,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/esm/components/syntax-highlighting-component.d.mts

@@ -0,0 +1,149 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Contains class {@link SyntaxHighlightingComponent} that registers syntax highlighting languages.
+ *
+ * Obsidian highlights code in two independent places, through two separate registries, and a plugin adding
+ * its own language usually has to touch both:
+ *
+ * - **Prism** (`prism.languages[language]`) highlights code in reading view and in every `<pre><code>` the
+ *   library renders — including the {@link CodeHighlighterComponent} settings field.
+ * - **The CodeMirror 5 mode registry** (`window.CodeMirror.modes[language]`) highlights a fenced code block
+ *   inside the editor.
+ *
+ * The CodeMirror 5 half looks like legacy that should be migrated to CodeMirror 6. **It is not** — verified
+ * against the Obsidian 1.13.4 runtime:
+ *
+ * - Obsidian's own CodeMirror 6 editor language is a bridged CodeMirror 5 mode:
+ *   `StreamLanguage.define(CodeMirror.getMode({}, { name: 'hypermd' }))`.
+ * - Obsidian registers that `hypermd` mode through `window.CodeMirror.defineMode` with
+ *   `fencedCodeBlockHighlighting: true`, and that option resolves each fence's language through the
+ *   **CodeMirror 5 mode registry**.
+ * - There is no public or internal CodeMirror 6 language-registration API for fences.
+ *
+ * So `window.CodeMirror.defineMode` is the sanctioned extension point, not legacy debt. Do not reopen this
+ * as a migration.
+ *
+ * Teardown REMOVES the mode rather than redefining it to `null`. Plugins predating this component redefined
+ * the mode to `null` on unload, because it was unclear whether CodeMirror's `getMode` needs the entry to
+ * stay present. It does not — verified against a live Obsidian 1.13.4 by
+ * `syntax-highlighting-component.obsidian.integration.test.ts`: after the entry is deleted, the fence
+ * renders its text with no error and drops back to the exact token count it had before the language was
+ * ever registered.
+ */
+import type { Grammar, PrismModule } from '@obsidian-typings/obsidian-public-latest';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * The loaded Prism module, handed to a grammar factory.
+ */
+export interface SyntaxHighlightingComponentGrammarFactoryParams {
+    /**
+     * The loaded Prism module.
+     */
+    readonly prism: PrismModule;
+    /**
+     * Returns the grammar of an already registered Prism language, for nesting into the built grammar.
+     *
+     * @param language - The language to look up.
+     * @returns The grammar of the language.
+     * @throws An {@link Error} if the language is not registered.
+     */
+    readonly requirePrismLanguage: (language: string) => Grammar;
+}
+/**
+ * A grammar, the name of an already registered language to alias, or a factory that builds the grammar from
+ * the loaded Prism module.
+ */
+export type SyntaxHighlightingComponentGrammarSource = ((params: SyntaxHighlightingComponentGrammarFactoryParams) => Grammar) | Grammar | string;
+/**
+ * Parameters for {@link SyntaxHighlightingComponent.registerCodeBlockLanguage}.
+ */
+export interface SyntaxHighlightingComponentRegisterCodeBlockLanguageParams {
+    /**
+     * The CodeMirror 5 mode name or MIME type the editor highlights the fence as, e.g. `text/typescript`.
+     */
+    readonly editorMode: string;
+    /**
+     * The fence language, e.g. the `foo` in a ` ```foo ` code block.
+     */
+    readonly language: string;
+    /**
+     * The grammar highlighting the fence in reading view. Omit when the fence is replaced in reading view —
+     * e.g. a fence rendered as a button.
+     */
+    readonly prismGrammar?: SyntaxHighlightingComponentGrammarSource | undefined;
+}
+/**
+ * Parameters for {@link SyntaxHighlightingComponent.registerPrismLanguage}.
+ */
+export interface SyntaxHighlightingComponentRegisterPrismLanguageParams {
+    /**
+     * The grammar to register.
+     */
+    readonly grammar: SyntaxHighlightingComponentGrammarSource;
+    /**
+     * The language to register the grammar as.
+     */
+    readonly language: string;
+}
+/**
+ * A component that registers and unregisters syntax highlighting languages.
+ *
+ * @remarks
+ * Every registration is undone when the component is unloaded: the previous entry is restored if the
+ * language was already registered, otherwise the entry is removed.
+ */
+export declare class SyntaxHighlightingComponent extends ComponentEx {
+    /**
+     * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.
+     *
+     * @param params - The parameters for registering the language.
+     * @returns A {@link Promise} that resolves when the language is registered.
+     *
+     * @example
+     * ```ts
+     * await component.registerCodeBlockLanguage({
+     *   editorMode: 'text/typescript',
+     *   language: 'my-language',
+     *   prismGrammar: 'typescript'
+     * });
+     * ```
+     */
+    registerCodeBlockLanguage(params: SyntaxHighlightingComponentRegisterCodeBlockLanguageParams): Promise<void>;
+    /**
+     * Registers a Prism language, highlighting it everywhere Prism renders code — reading view and the
+     * {@link CodeHighlighterComponent} settings field.
+     *
+     * @param params - The parameters for registering the language.
+     * @returns A {@link Promise} that resolves when the language is registered.
+     *
+     * @example
+     * ```ts
+     * await component.registerPrismLanguage({
+     *   grammar: {
+     *     keyword: /\bfoo\b/
+     *   },
+     *   language: 'my-language'
+     * });
+     * ```
+     */
+    registerPrismLanguage(params: SyntaxHighlightingComponentRegisterPrismLanguageParams): Promise<void>;
+    /**
+     * Returns the grammar of an already registered Prism language.
+     *
+     * @param prism - The loaded Prism module.
+     * @param language - The language to look up.
+     * @returns The grammar of the language.
+     * @throws An {@link Error} if the language is not registered.
+     */
+    private requirePrismLanguage;
+    /**
+     * Resolves a grammar source into the grammar to register.
+     *
+     * @param prism - The loaded Prism module.
+     * @param grammarSource - The grammar source to resolve.
+     * @returns The resolved grammar.
+     */
+    private resolveGrammar;
+}