obsidian-dev-utils 86.1.3 → 87.0.0

package/dist/lib/esm/obsidian/desktop-demo-vault-opener.mjs

@@ -28,7 +28,10 @@ import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { requestUrl } from "obsidian";
 import { join } from "../path.mjs";
-import { getCommunityPluginRepo } from "./community-plugins.mjs";
+import {
+  getCommunityPluginRepo,
+  getLatestReleaseVersion
+} from "./community-plugins.mjs";
 import { selectOption } from "./modals/select-option.mjs";
 const DEMO_VAULTS_CACHE_FOLDER = "obsidian-demo-vaults";
 const HTTP_STATUS_OK = 200;
@@ -110,12 +113,7 @@ async function downloadAndExtractDemoVault(params) {
   zip.extractAllTo(cacheDir, true);
   return true;
 }
-async function getLatestReleaseVersion(repo) {
-  const response = await requestUrl(`https://api.github.com/repos/${repo}/releases/latest`);
-  const release = response.json;
-  return release.tag_name;
-}
 export {
   openDemoVault
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `demo-vault-<version>.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository\n * from Obsidian's community registry, downloads the archive for the chosen version, extracts it to a\n * per-version cache folder under the OS temp directory, and opens that folder as a vault in a new\n * window. When the installed plugin version is behind the latest release, the user is offered a choice\n * between the two versions.\n */\n\nimport type {\n  App,\n  PluginManifest\n} from 'obsidian';\n\nimport AdmZip from 'adm-zip';\nimport { compareVersions } from 'compare-versions';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { Buffer } from 'node:buffer';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { existsSync } from 'node:fs';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { tmpdir } from 'node:os';\nimport { requestUrl } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { join } from '../path.ts';\nimport { getCommunityPluginRepo } from './community-plugins.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The manifest of the plugin whose demo vault is opened. Its `id` locates the GitHub repository, its\n   * `version` selects the archive, and its `name` labels the notices and the version-choice dialog.\n   */\n  readonly manifest: PluginManifest;\n\n  /**\n   * The notice component used to report problems (plugin not in the registry, missing archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n}\n\ninterface DownloadAndExtractDemoVaultParams {\n  readonly cacheDir: string;\n  readonly manifest: PluginManifest;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly repo: string;\n  readonly version: string;\n}\n\ninterface GitHubRelease {\n  /**\n   * The release tag, a bare version such as `1.2.3`.\n   */\n  readonly tag_name: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst HTTP_STATUS_OK = 200;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. The chosen version's\n * archive is downloaded and extracted once, then reused from a per-version cache folder.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    manifest,\n    pluginNoticeComponent\n  } = params;\n\n  const repo = await getCommunityPluginRepo(manifest.id);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${manifest.name} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = manifest.version;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${manifest.name} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: manifest.name\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const cacheDir = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, manifest.id, versionToOpen);\n  if (!existsSync(cacheDir)) {\n    const isExtracted = await downloadAndExtractDemoVault({\n      cacheDir,\n      manifest,\n      pluginNoticeComponent,\n      repo,\n      version: versionToOpen\n    });\n    if (!isExtracted) {\n      return;\n    }\n  }\n\n  window.electron.ipcRenderer.sendSync('vault-open', cacheDir, false);\n}\n\nasync function downloadAndExtractDemoVault(params: DownloadAndExtractDemoVaultParams): Promise<boolean> {\n  const {\n    cacheDir,\n    manifest,\n    pluginNoticeComponent,\n    repo,\n    version\n  } = params;\n\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/demo-vault-${version}.zip`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${manifest.name} v${version}.`);\n    return false;\n  }\n\n  const zip = new AdmZip(Buffer.from(response.arrayBuffer));\n  zip.extractAllTo(cacheDir, true);\n  return true;\n}\n\nasync function getLatestReleaseVersion(repo: string): Promise<string> {\n  const response = await requestUrl(`https://api.github.com/repos/${repo}/releases/latest`);\n  const release = response.json as GitHubRelease;\n  return release.tag_name;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAkBA,OAAO,YAAY;AACnB,SAAS,uBAAuB;AAEhC,SAAS,cAAc;AAEvB,SAAS,kBAAkB;AAE3B,SAAS,cAAc;AACvB,SAAS,kBAAkB;AAI3B,SAAS,YAAY;AACrB,SAAS,8BAA8B;AACvC,SAAS,oBAAoB;AAsC7B,MAAM,2BAA2B;AACjC,MAAM,iBAAiB;AAavB,eAAsB,cAAc,QAA4C;AAC9E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,OAAO,MAAM,uBAAuB,SAAS,EAAE;AACrD,MAAI,CAAC,MAAM;AACT,0BAAsB,WAAW,yBAAyB,SAAS,IAAI,qCAAqC;AAC5G;AAAA,EACF;AAEA,QAAM,iBAAiB,SAAS;AAChC,QAAM,gBAAgB,MAAM,wBAAwB,IAAI;AAExD,MAAI;AACJ,MAAI,gBAAgB,gBAAgB,aAAa,KAAK,GAAG;AACvD,oBAAgB;AAAA,EAClB,OAAO;AACL,UAAM,gBAAgB,MAAM,aAA4B;AAAA,MACtD;AAAA,MACA,SAAS,6BAA6B,SAAS,IAAI,KAAK,cAAc,wBAAwB,aAAa;AAAA,MAC3G,SAAS;AAAA,QACP;AAAA,UACE,OAAO;AAAA,UACP,MAAM,wCAAwC,aAAa;AAAA,UAC3D,OAAO;AAAA,QACT;AAAA,QACA;AAAA,UACE,MAAM,yCAAyC,cAAc;AAAA,UAC7D,OAAO;AAAA,QACT;AAAA,QACA;AAAA,UACE,MAAM;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAAA,MACA,OAAO,SAAS;AAAA,IAClB,CAAC;AACD,QAAI,kBAAkB,MAAM;AAC1B;AAAA,IACF;AACA,oBAAgB;AAAA,EAClB;AAEA,QAAM,WAAW,KAAK,OAAO,GAAG,0BAA0B,SAAS,IAAI,aAAa;AACpF,MAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,UAAM,cAAc,MAAM,4BAA4B;AAAA,MACpD;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AACD,QAAI,CAAC,aAAa;AAChB;AAAA,IACF;AAAA,EACF;AAEA,SAAO,SAAS,YAAY,SAAS,cAAc,UAAU,KAAK;AACpE;AAEA,eAAe,4BAA4B,QAA6D;AACtG,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,WAAW,sBAAsB,IAAI,sBAAsB,OAAO,eAAe,OAAO;AAC9F,QAAM,WAAW,MAAM,WAAW;AAAA,IAChC,OAAO;AAAA,IACP,KAAK;AAAA,EACP,CAAC;AACD,MAAI,SAAS,WAAW,gBAAgB;AACtC,0BAAsB,WAAW,yCAAyC,SAAS,IAAI,KAAK,OAAO,GAAG;AACtG,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,IAAI,OAAO,OAAO,KAAK,SAAS,WAAW,CAAC;AACxD,MAAI,aAAa,UAAU,IAAI;AAC/B,SAAO;AACT;AAEA,eAAe,wBAAwB,MAA+B;AACpE,QAAM,WAAW,MAAM,WAAW,gCAAgC,IAAI,kBAAkB;AACxF,QAAM,UAAU,SAAS;AACzB,SAAO,QAAQ;AACjB;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `demo-vault-<version>.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository\n * from Obsidian's community registry, downloads the archive for the chosen version, extracts it to a\n * per-version cache folder under the OS temp directory, and opens that folder as a vault in a new\n * window. When the installed plugin version is behind the latest release, the user is offered a choice\n * between the two versions.\n */\n\nimport type {\n  App,\n  PluginManifest\n} from 'obsidian';\n\nimport AdmZip from 'adm-zip';\nimport { compareVersions } from 'compare-versions';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { Buffer } from 'node:buffer';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { existsSync } from 'node:fs';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { tmpdir } from 'node:os';\nimport { requestUrl } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { join } from '../path.ts';\nimport {\n  getCommunityPluginRepo,\n  getLatestReleaseVersion\n} from './community-plugins.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The manifest of the plugin whose demo vault is opened. Its `id` locates the GitHub repository, its\n   * `version` selects the archive, and its `name` labels the notices and the version-choice dialog.\n   */\n  readonly manifest: PluginManifest;\n\n  /**\n   * The notice component used to report problems (plugin not in the registry, missing archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n}\n\ninterface DownloadAndExtractDemoVaultParams {\n  readonly cacheDir: string;\n  readonly manifest: PluginManifest;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly repo: string;\n  readonly version: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst HTTP_STATUS_OK = 200;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. The chosen version's\n * archive is downloaded and extracted once, then reused from a per-version cache folder.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    manifest,\n    pluginNoticeComponent\n  } = params;\n\n  const repo = await getCommunityPluginRepo(manifest.id);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${manifest.name} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = manifest.version;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${manifest.name} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: manifest.name\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const cacheDir = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, manifest.id, versionToOpen);\n  if (!existsSync(cacheDir)) {\n    const isExtracted = await downloadAndExtractDemoVault({\n      cacheDir,\n      manifest,\n      pluginNoticeComponent,\n      repo,\n      version: versionToOpen\n    });\n    if (!isExtracted) {\n      return;\n    }\n  }\n\n  window.electron.ipcRenderer.sendSync('vault-open', cacheDir, false);\n}\n\nasync function downloadAndExtractDemoVault(params: DownloadAndExtractDemoVaultParams): Promise<boolean> {\n  const {\n    cacheDir,\n    manifest,\n    pluginNoticeComponent,\n    repo,\n    version\n  } = params;\n\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/demo-vault-${version}.zip`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${manifest.name} v${version}.`);\n    return false;\n  }\n\n  const zip = new AdmZip(Buffer.from(response.arrayBuffer));\n  zip.extractAllTo(cacheDir, true);\n  return true;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAkBA,OAAO,YAAY;AACnB,SAAS,uBAAuB;AAEhC,SAAS,cAAc;AAEvB,SAAS,kBAAkB;AAE3B,SAAS,cAAc;AACvB,SAAS,kBAAkB;AAI3B,SAAS,YAAY;AACrB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,oBAAoB;AA+B7B,MAAM,2BAA2B;AACjC,MAAM,iBAAiB;AAavB,eAAsB,cAAc,QAA4C;AAC9E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,OAAO,MAAM,uBAAuB,SAAS,EAAE;AACrD,MAAI,CAAC,MAAM;AACT,0BAAsB,WAAW,yBAAyB,SAAS,IAAI,qCAAqC;AAC5G;AAAA,EACF;AAEA,QAAM,iBAAiB,SAAS;AAChC,QAAM,gBAAgB,MAAM,wBAAwB,IAAI;AAExD,MAAI;AACJ,MAAI,gBAAgB,gBAAgB,aAAa,KAAK,GAAG;AACvD,oBAAgB;AAAA,EAClB,OAAO;AACL,UAAM,gBAAgB,MAAM,aAA4B;AAAA,MACtD;AAAA,MACA,SAAS,6BAA6B,SAAS,IAAI,KAAK,cAAc,wBAAwB,aAAa;AAAA,MAC3G,SAAS;AAAA,QACP;AAAA,UACE,OAAO;AAAA,UACP,MAAM,wCAAwC,aAAa;AAAA,UAC3D,OAAO;AAAA,QACT;AAAA,QACA;AAAA,UACE,MAAM,yCAAyC,cAAc;AAAA,UAC7D,OAAO;AAAA,QACT;AAAA,QACA;AAAA,UACE,MAAM;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAAA,MACA,OAAO,SAAS;AAAA,IAClB,CAAC;AACD,QAAI,kBAAkB,MAAM;AAC1B;AAAA,IACF;AACA,oBAAgB;AAAA,EAClB;AAEA,QAAM,WAAW,KAAK,OAAO,GAAG,0BAA0B,SAAS,IAAI,aAAa;AACpF,MAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,UAAM,cAAc,MAAM,4BAA4B;AAAA,MACpD;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AACD,QAAI,CAAC,aAAa;AAChB;AAAA,IACF;AAAA,EACF;AAEA,SAAO,SAAS,YAAY,SAAS,cAAc,UAAU,KAAK;AACpE;AAEA,eAAe,4BAA4B,QAA6D;AACtG,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,WAAW,sBAAsB,IAAI,sBAAsB,OAAO,eAAe,OAAO;AAC9F,QAAM,WAAW,MAAM,WAAW;AAAA,IAChC,OAAO;AAAA,IACP,KAAK;AAAA,EACP,CAAC;AACD,MAAI,SAAS,WAAW,gBAAgB;AACtC,0BAAsB,WAAW,yCAAyC,SAAS,IAAI,KAAK,OAAO,GAAG;AACtG,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,IAAI,OAAO,OAAO,KAAK,SAAS,WAAW,CAAC;AACxD,MAAI,aAAa,UAAU,IAAI;AAC/B,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/obsidian/events.d.mts

@@ -0,0 +1,98 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Typed helpers for subscribing to an Obsidian {@link Events} source. Both derive the valid event names and their
+ * callback argument types from the source's overloaded `on` method (via {@link ExtractEventMap}), so the event
+ * name and handler are fully autocompleted. {@link subscribeEvent} returns the raw {@link EventRef} (parity with
+ * {@link Events.on}); {@link subscribeDisposableEvent} returns a {@link DisposableEx} that unregisters it.
+ */
+import type { EventRef, Events } from 'obsidian';
+import type { DisposableEx } from '../disposable.mjs';
+import type { ExtractEventMap } from '../type.mjs';
+import { DisposableBase } from '../disposable.mjs';
+/**
+ * Parameters for {@link subscribeDisposableEvent}. Same shape as {@link SubscribeEventParams}.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name, constrained to the source's known events.
+ */
+export type SubscribeDisposableEventParams<Source extends Events, EventName extends EventNameOf<Source>> = SubscribeEventParams<Source, EventName>;
+/**
+ * Parameters for {@link subscribeEvent}.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name, constrained to the source's known events.
+ */
+export interface SubscribeEventParams<Source extends Events, EventName extends EventNameOf<Source>> {
+    /**
+     * The event callback. Its argument types are inferred from {@link SubscribeEventParams.name}.
+     */
+    readonly callback: EventCallbackOf<Source, EventName>;
+    /**
+     * The event source to subscribe on.
+     */
+    readonly events: Source;
+    /**
+     * The event name to subscribe to.
+     */
+    readonly name: EventName;
+    /**
+     * The context passed as `this` to the callback.
+     */
+    readonly thisArg?: unknown;
+}
+/**
+ * The callback type for a given event on a {@link Events} source, with its argument tuple inferred from
+ * {@link ExtractEventMap}.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name.
+ */
+type EventCallbackOf<Source extends Events, EventName extends EventNameOf<Source>> = ExtractEventMap<Source>[EventName] extends infer Args extends unknown[] ? (...args: Args) => unknown : never;
+/**
+ * The union of known event names for a {@link Events} source, derived from its `on` overloads.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ */
+type EventNameOf<Source extends Events> = keyof ExtractEventMap<Source> & string;
+/**
+ * A {@link DisposableEx} that unregisters an Obsidian {@link EventRef} on dispose, via the event source exposed on
+ * the ref itself (`eventRef.e`).
+ */
+export declare class EventRefDisposable extends DisposableBase {
+    private readonly eventRef;
+    /**
+     * Creates a disposable wrapping an existing {@link EventRef}.
+     *
+     * @param eventRef - The event reference to unregister on dispose.
+     */
+    constructor(eventRef: EventRef);
+    /**
+     * Unregisters the event via the source stored on the ref (`eventRef.e.offref`).
+     */
+    protected performDispose(): void;
+}
+/**
+ * Subscribes to an event on an {@link Events} source and returns a {@link DisposableEx} that unregisters it on
+ * dispose. Typed wrapper over {@link Events.on}: the event name and callback arguments are autocompleted from the
+ * source's overloads.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name.
+ * @param params - The subscription parameters.
+ * @returns A {@link DisposableEx} that unregisters the handler when disposed.
+ */
+export declare function subscribeDisposableEvent<Source extends Events, EventName extends EventNameOf<Source>>(params: SubscribeDisposableEventParams<Source, EventName>): DisposableEx;
+/**
+ * Subscribes to an event on an {@link Events} source and returns the raw {@link EventRef} (parity with
+ * {@link Events.on}). Typed wrapper: the event name and callback arguments are autocompleted from the source's
+ * overloads.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name.
+ * @param params - The subscription parameters.
+ * @returns The {@link EventRef} for the registered handler.
+ */
+export declare function subscribeEvent<Source extends Events, EventName extends EventNameOf<Source>>(params: SubscribeEventParams<Source, EventName>): EventRef;
+export {};

package/dist/lib/esm/obsidian/events.mjs

@@ -0,0 +1,55 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { DisposableBase } from "../disposable.mjs";
+import { castTo } from "../object-utils.mjs";
+class EventRefDisposable extends DisposableBase {
+  /**
+   * Creates a disposable wrapping an existing {@link EventRef}.
+   *
+   * @param eventRef - The event reference to unregister on dispose.
+   */
+  constructor(eventRef) {
+    super();
+    this.eventRef = eventRef;
+  }
+  eventRef;
+  /**
+   * Unregisters the event via the source stored on the ref (`eventRef.e.offref`).
+   */
+  performDispose() {
+    this.eventRef.e.offref(this.eventRef);
+  }
+}
+function subscribeDisposableEvent(params) {
+  return new EventRefDisposable(subscribeEvent(params));
+}
+function subscribeEvent(params) {
+  return params.events.on(params.name, castTo(params.callback), params.thisArg);
+}
+export {
+  EventRefDisposable,
+  subscribeDisposableEvent,
+  subscribeEvent
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/i18n/locales/en.d.mts

@@ -34,7 +34,6 @@ export declare const en: {
         readonly notices: {
             readonly attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.";
             readonly closeAriaLabel: "Close";
-            readonly closeConfirmMessage: "Are you sure you want to close the notice?";
             readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
         };
         readonly queue: {

package/dist/lib/esm/obsidian/i18n/locales/en.mjs

@@ -48,7 +48,6 @@ const en = {
     notices: {
       attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.",
       closeAriaLabel: "Close",
-      closeConfirmMessage: "Are you sure you want to close the notice?",
       unhandledError: "An unhandled error occurred. Please check the console for more information."
     },
     queue: {
@@ -75,4 +74,4 @@ const en = {
 export {
   en
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/i18n/locales/translations-map.d.mts

@@ -37,7 +37,6 @@ declare const translationsMapImpl: {
             readonly notices: {
                 readonly attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.";
                 readonly closeAriaLabel: "Close";
-                readonly closeConfirmMessage: "Are you sure you want to close the notice?";
                 readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
             };
             readonly queue: {

package/dist/lib/esm/obsidian/index.d.mts

@@ -22,6 +22,7 @@ export * as 'desktop-trusted-input' from './desktop-trusted-input.mjs';
 export * as 'editor-extension-registrar' from './editor-extension-registrar.mjs';
 export * as 'editor-suggest-registrar' from './editor-suggest-registrar.mjs';
 export * as 'editor' from './editor.mjs';
+export * as 'events' from './events.mjs';
 export * as 'extensions-registrar' from './extensions-registrar.mjs';
 export * as 'file-change' from './file-change.mjs';
 export * as 'file-manager' from './file-manager.mjs';

package/dist/lib/esm/obsidian/index.mjs

@@ -44,6 +44,7 @@ import * as desktop_trusted_input from "./desktop-trusted-input.mjs";
 import * as editor_extension_registrar from "./editor-extension-registrar.mjs";
 import * as editor_suggest_registrar from "./editor-suggest-registrar.mjs";
 import * as editor from "./editor.mjs";
+import * as events from "./events.mjs";
 import * as extensions_registrar from "./extensions-registrar.mjs";
 import * as file_change from "./file-change.mjs";
 import * as file_manager from "./file-manager.mjs";
@@ -112,6 +113,7 @@ export {
   editor,
   editor_extension_registrar as "editor-extension-registrar",
   editor_suggest_registrar as "editor-suggest-registrar",
+  events,
   extensions_registrar as "extensions-registrar",
   file_change as "file-change",
   file_manager as "file-manager",
@@ -157,4 +159,4 @@ export {
   view_registrar as "view-registrar",
   workspace
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,aAAe;AAC3B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAY,YAAc;AAC1B,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "bases-view-registrar", "case-insensitive-file-index", "code-block-markdown-information", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "dataview-link", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-manager", "file-system", "frontmatter-link-cache-with-offsets", "hover-link-source-registrar", "html-element", "is-in-obsidian", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "obsidian-protocol-handler-registrar", "obsidian-settings", "parse-link", "path-settings", "plugin-cli-handler-registrar", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "vault-delete", "vault-transaction", "view-registrar"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'events' from './events.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,aAAe;AAC3B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAY,YAAc;AAC1B,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "bases-view-registrar", "case-insensitive-file-index", "code-block-markdown-information", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "dataview-link", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-manager", "file-system", "frontmatter-link-cache-with-offsets", "hover-link-source-registrar", "html-element", "is-in-obsidian", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "obsidian-protocol-handler-registrar", "obsidian-settings", "parse-link", "path-settings", "plugin-cli-handler-registrar", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "vault-delete", "vault-transaction", "view-registrar"]
}


package/dist/lib/esm/obsidian/menu-event-registrar.d.mts

@@ -5,6 +5,7 @@
  * Menu event registrar.
  */
 import type { Editor, MarkdownFileInfo, Menu, TAbstractFile, WorkspaceLeaf } from 'obsidian';
+import type { DisposableEx } from '../disposable.mjs';
 /**
  * Handler for the editor context menu event.
  *
@@ -39,18 +40,21 @@ export interface MenuEventRegistrar {
      * Registers a handler for the editor context menu event.
      *
      * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
      */
-    registerEditorMenuEventHandler(handler: EditorMenuEventHandler): void;
+    registerEditorMenuEventHandler(handler: EditorMenuEventHandler): DisposableEx;
     /**
      * Registers a handler for the single-file context menu event.
      *
      * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
      */
-    registerFileMenuEventHandler(handler: FileMenuEventHandler): void;
+    registerFileMenuEventHandler(handler: FileMenuEventHandler): DisposableEx;
     /**
      * Registers a handler for the multi-file context menu event.
      *
      * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
      */
-    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): void;
+    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): DisposableEx;
 }

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/change-extension-plugin.d.mts

@@ -12,3 +12,14 @@ import type { Plugin } from 'esbuild';
  * @returns An esbuild `Plugin` object that handles the renaming and modification of output files.
  */
 export declare function changeExtensionPlugin(extension: string): Plugin;
+/**
+ * Rewrites the extension of every import-like path in an emitted module's text from `.ts` to the target
+ * output extension (`.mjs` / `.cjs`), so the multi-file `dist/lib` build references its real siblings.
+ *
+ * Covers `require('…')`, static `from "…"`, and dynamic `import("…")` occurrences.
+ *
+ * @param text - The emitted module text to rewrite.
+ * @param extension - The output extension to rewrite `.ts` paths to (e.g. `.mjs` or `.cjs`).
+ * @returns The rewritten module text.
+ */
+export declare function rewriteImportPathExtensions(text: string, extension: string): string;

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/change-extension-plugin.mjs

@@ -38,43 +38,40 @@ function changeExtensionPlugin(extension) {
             searchValue: /\.js$/g,
             str: file.path
           });
-          let newText = replaceAll({
-            replacer: ({ capturedGroupArgs: [importPath = ""] }) => {
-              if (importPath.endsWith(ObsidianDevUtilsRepoPaths.DtsExtension)) {
-                return "undefined";
-              }
-              const fixedImportPath = replaceAll({
-                replacer: extension,
-                searchValue: /\.ts$/g,
-                str: importPath
-              });
-              return `require('${fixedImportPath}')`;
-            },
-            searchValue: /require\(["'](?<ImportPath>.+?)["']\)/g,
-            str: file.text
-          });
-          newText = replaceAll({
-            replacer: ({ capturedGroupArgs: [importPath = ""] }) => {
-              if (importPath.endsWith(ObsidianDevUtilsRepoPaths.DtsExtension)) {
-                return "undefined";
-              }
-              const fixedImportPath = replaceAll({
-                replacer: extension,
-                searchValue: /\.ts$/g,
-                str: importPath
-              });
-              return `from "${fixedImportPath}"`;
-            },
-            searchValue: /from "(?<ImportPath>.+?)"/g,
-            str: newText
-          });
+          const newText = rewriteImportPathExtensions(file.text, extension);
           await writeFile(newPath, newText);
         }
       });
     }
   };
 }
+function rewriteImportPathExtensions(text, extension) {
+  let newText = replaceAll({
+    replacer: ({ capturedGroupArgs: [importPath = ""] }) => `require('${rewriteTsExtension(importPath, extension)}')`,
+    searchValue: /require\(["'](?<ImportPath>.+?)["']\)/g,
+    str: text
+  });
+  newText = replaceAll({
+    replacer: ({ capturedGroupArgs: [importPath = ""] }) => `from "${rewriteTsExtension(importPath, extension)}"`,
+    searchValue: /from "(?<ImportPath>.+?)"/g,
+    str: newText
+  });
+  newText = replaceAll({
+    replacer: ({ capturedGroupArgs: [importPath = ""] }) => `import("${rewriteTsExtension(importPath, extension)}")`,
+    searchValue: /import\(["'](?<ImportPath>.+?)["']\)/g,
+    str: newText
+  });
+  return newText;
+}
+function rewriteTsExtension(importPath, extension) {
+  return replaceAll({
+    replacer: extension,
+    searchValue: /\.ts$/g,
+    str: importPath
+  });
+}
 export {
-  changeExtensionPlugin
+  changeExtensionPlugin,
+  rewriteImportPathExtensions
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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