obsidian-dev-utils 86.1.2 → 86.2.0

package/dist/lib/cjs/obsidian/community-plugins.cjs

@@ -125,32 +125,132 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var community_plugins_exports = {};
 __export(community_plugins_exports, {
-  getCommunityPluginRepo: () => getCommunityPluginRepo
+  disableCommunityPlugin: () => disableCommunityPlugin,
+  enableCommunityPlugin: () => enableCommunityPlugin,
+  getCommunityPluginRepo: () => getCommunityPluginRepo,
+  getLatestReleaseVersion: () => getLatestReleaseVersion,
+  installCommunityPlugin: () => installCommunityPlugin,
+  searchCommunityPlugins: () => searchCommunityPlugins,
+  toggleEnableCommunityPlugin: () => toggleEnableCommunityPlugin,
+  toggleInstallCommunityPlugin: () => toggleInstallCommunityPlugin,
+  uninstallCommunityPlugin: () => uninstallCommunityPlugin
 });
 module.exports = __toCommonJS(community_plugins_exports);
 var import_obsidian = require('obsidian');
 var import_obsidian_dev_utils_state = require('../obsidian-dev-utils-state.cjs');
 const COMMUNITY_PLUGINS_STATE_KEY = "communityPluginEntriesPromise";
 const COMMUNITY_PLUGINS_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
+async function disableCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (!app.plugins.enabledPlugins.has(pluginId)) {
+    return;
+  }
+  await app.plugins.disablePluginAndSave(pluginId);
+}
+async function enableCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (app.plugins.enabledPlugins.has(pluginId)) {
+    return;
+  }
+  await app.plugins.enablePluginAndSave(pluginId);
+}
 async function getCommunityPluginRepo(pluginId) {
+  const entries = await getCommunityPluginEntries();
+  const entry = entries.find((candidate) => candidate.id === pluginId);
+  return entry?.repo ?? null;
+}
+async function getLatestReleaseVersion(repo) {
+  const response = await (0, import_obsidian.requestUrl)(`https://api.github.com/repos/${repo}/releases/latest`);
+  const release = response.json;
+  return release.tag_name;
+}
+async function installCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (app.plugins.manifests[pluginId]) {
+    return;
+  }
+  const repo = await getCommunityPluginRepo(pluginId);
+  if (!repo) {
+    throw new Error(`Plugin '${pluginId}' was not found in the Obsidian community plugins registry.`);
+  }
+  const version = await getLatestReleaseVersion(repo);
+  const manifest = await getPluginManifest(repo, version);
+  await app.plugins.installPlugin(repo, version, manifest);
+}
+async function searchCommunityPlugins(query) {
+  const entries = await getCommunityPluginEntries();
+  const normalizedQuery = query.toLowerCase();
+  return entries.filter(
+    (entry) => entry.id.toLowerCase().includes(normalizedQuery) || entry.name.toLowerCase().includes(normalizedQuery) || entry.author.toLowerCase().includes(normalizedQuery) || entry.description.toLowerCase().includes(normalizedQuery)
+  ).map((entry) => ({
+    id: entry.id,
+    name: entry.name
+  }));
+}
+async function toggleEnableCommunityPlugin(params) {
+  if (params.isEnabled) {
+    await enableCommunityPlugin(params);
+  } else {
+    await disableCommunityPlugin(params);
+  }
+}
+async function toggleInstallCommunityPlugin(params) {
+  if (params.isInstalled) {
+    await installCommunityPlugin(params);
+  } else {
+    await uninstallCommunityPlugin(params);
+  }
+}
+async function uninstallCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (!app.plugins.manifests[pluginId]) {
+    return;
+  }
+  await app.plugins.uninstallPlugin(pluginId);
+}
+async function fetchCommunityPluginEntries() {
+  const response = await (0, import_obsidian.requestUrl)(COMMUNITY_PLUGINS_URL);
+  return response.json;
+}
+async function getCommunityPluginEntries() {
   const cache = (0, import_obsidian_dev_utils_state.getObsidianDevUtilsState)(COMMUNITY_PLUGINS_STATE_KEY, null);
   cache.value ??= fetchCommunityPluginEntries();
-  let entries;
   try {
-    entries = await cache.value;
+    return await cache.value;
   } catch (error) {
     cache.value = null;
     throw error;
   }
-  const entry = entries.find((candidate) => candidate.id === pluginId);
-  return entry?.repo ?? null;
 }
-async function fetchCommunityPluginEntries() {
-  const response = await (0, import_obsidian.requestUrl)(COMMUNITY_PLUGINS_URL);
+async function getPluginManifest(repo, version) {
+  const response = await (0, import_obsidian.requestUrl)(`https://github.com/${repo}/releases/download/${version}/manifest.json`);
   return response.json;
 }
+async function resolveCommunityPluginId(ref) {
+  if ("pluginId" in ref) {
+    return ref.pluginId;
+  }
+  const entries = await getCommunityPluginEntries();
+  const entry = entries.find((candidate) => candidate.name === ref.pluginName);
+  if (!entry) {
+    throw new Error(`Plugin named '${ref.pluginName}' was not found in the Obsidian community plugins registry.`);
+  }
+  return entry.id;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getCommunityPluginRepo
+  disableCommunityPlugin,
+  enableCommunityPlugin,
+  getCommunityPluginRepo,
+  getLatestReleaseVersion,
+  installCommunityPlugin,
+  searchCommunityPlugins,
+  toggleEnableCommunityPlugin,
+  toggleInstallCommunityPlugin,
+  uninstallCommunityPlugin
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/community-plugins.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Resolves, searches and manages community plugins through Obsidian's public plugin registry and\n * store-install path.\n *\n * Obsidian's `community-plugins.json` is the authoritative source that maps a plugin `id` to its\n * `owner/name` GitHub repository \u2014 the plugin manifest itself carries no repository. This module uses\n * it to search the registry, to locate a plugin's GitHub releases (e.g. to download its shipped\n * demo-vault archive), and to install/uninstall/enable/disable an arbitrary community plugin \u2014 selected\n * by either its `id` or its display `name` \u2014 via Obsidian's own store path (`app.plugins.installPlugin`\n * + `enablePluginAndSave`), so any dev/deploy or tooling flow can reuse it.\n */\n\nimport type {\n  App,\n  PluginManifest\n} from 'obsidian';\n\nimport { requestUrl } from 'obsidian';\n\nimport { getObsidianDevUtilsState } from '../obsidian-dev-utils-state.ts';\n\n/**\n * Selects a community plugin either by its id ({@link CommunityPluginByIdRef}) or by its display name\n * ({@link CommunityPluginByNameRef}).\n */\nexport type CommunityPluginRef = CommunityPluginByIdRef | CommunityPluginByNameRef;\n\n/**\n * A single result of {@link searchCommunityPlugins}.\n */\nexport interface CommunityPluginSearchResult {\n  /**\n   * The plugin id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin display name.\n   */\n  readonly name: string;\n}\n\n/**\n * Parameters for {@link disableCommunityPlugin}. Selects the plugin by either `pluginId` or\n * `pluginName`.\n */\nexport type DisableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;\n\n/**\n * Parameters for {@link enableCommunityPlugin}. Selects the plugin by either `pluginId` or\n * `pluginName`.\n */\nexport type EnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;\n\n/**\n * Parameters for {@link installCommunityPlugin}. Selects the plugin by either `pluginId` or\n * `pluginName`.\n */\nexport type InstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;\n\n/**\n * Parameters for {@link toggleEnableCommunityPlugin}. Selects the plugin by either `pluginId` or\n * `pluginName`.\n */\nexport type ToggleEnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginToggleEnableState;\n\n/**\n * Parameters for {@link toggleInstallCommunityPlugin}. Selects the plugin by either `pluginId` or\n * `pluginName`.\n */\nexport type ToggleInstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginToggleInstallState;\n\n/**\n * Parameters for {@link uninstallCommunityPlugin}. Selects the plugin by either `pluginId` or\n * `pluginName`.\n */\nexport type UninstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;\n\n/**\n * Selects a community plugin by its id.\n */\ninterface CommunityPluginByIdRef {\n  /**\n   * The plugin id.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Selects a community plugin by its display name (as listed in Obsidian's community registry).\n */\ninterface CommunityPluginByNameRef {\n  /**\n   * The plugin display name.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * A single entry in Obsidian's `community-plugins.json` registry.\n */\ninterface CommunityPluginEntry {\n  /**\n   * The plugin author.\n   */\n  readonly author: string;\n\n  /**\n   * The plugin description.\n   */\n  readonly description: string;\n\n  /**\n   * The plugin id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin display name.\n   */\n  readonly name: string;\n\n  /**\n   * The plugin's `owner/name` GitHub repository.\n   */\n  readonly repo: string;\n}\n\n/**\n * The Obsidian app instance a community-plugin operation runs against.\n */\ninterface CommunityPluginOperationContext {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n}\n\n/**\n * The desired enabled state for {@link toggleEnableCommunityPlugin}.\n */\ninterface CommunityPluginToggleEnableState {\n  /**\n   * The desired enabled state: `true` enables the plugin, `false` disables it.\n   */\n  readonly isEnabled: boolean;\n}\n\n/**\n * The desired installed state for {@link toggleInstallCommunityPlugin}.\n */\ninterface CommunityPluginToggleInstallState {\n  /**\n   * The desired installed state: `true` installs the plugin, `false` uninstalls it.\n   */\n  readonly isInstalled: boolean;\n}\n\n/**\n * The subset of a GitHub release we read.\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 COMMUNITY_PLUGINS_STATE_KEY = 'communityPluginEntriesPromise';\nconst COMMUNITY_PLUGINS_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json';\n\n/**\n * Disables a community plugin (persisting the change) if it is currently enabled. Idempotent \u2014 a no-op\n * when the plugin is already disabled.\n *\n * @param params - The {@link DisableCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is disabled.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function disableCommunityPlugin(params: DisableCommunityPluginParams): Promise<void> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (!app.plugins.enabledPlugins.has(pluginId)) {\n    return;\n  }\n  await app.plugins.disablePluginAndSave(pluginId);\n}\n\n/**\n * Enables a community plugin (persisting the change) if it is not already enabled. Idempotent \u2014 a no-op\n * when the plugin is already enabled.\n *\n * @param params - The {@link EnableCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is enabled.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function enableCommunityPlugin(params: EnableCommunityPluginParams): Promise<void> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (app.plugins.enabledPlugins.has(pluginId)) {\n    return;\n  }\n  await app.plugins.enablePluginAndSave(pluginId);\n}\n\n/**\n * Resolves the `owner/name` GitHub repository of a community plugin from Obsidian's public\n * `community-plugins.json` registry.\n *\n * The registry is fetched once and cached on the shared plugin state for subsequent calls; a failed\n * fetch is not cached, so a later call retries.\n *\n * @param pluginId - The plugin id to look up.\n * @returns A {@link Promise} resolving to the plugin's `owner/name` repository, or `null` if the\n * plugin is not listed in the registry.\n */\nexport async function getCommunityPluginRepo(pluginId: string): Promise<null | string> {\n  const entries = await getCommunityPluginEntries();\n  const entry = entries.find((candidate) => candidate.id === pluginId);\n  return entry?.repo ?? null;\n}\n\n/**\n * Resolves the latest release version (the release `tag_name`, a bare version such as `1.2.3`) of a\n * GitHub repository.\n *\n * @param repo - The `owner/name` GitHub repository.\n * @returns A {@link Promise} resolving to the latest release version.\n */\nexport async 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\n/**\n * Installs a community plugin from the official store if it is not already installed. Idempotent \u2014 a\n * no-op when the plugin is already installed. Resolves the plugin's repository from Obsidian's\n * community registry, reads the latest release version and its manifest, and installs it through\n * Obsidian's own `installPlugin` path.\n *\n * @param params - The {@link InstallCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is installed.\n * @throws If the plugin is not listed in Obsidian's community plugins registry.\n */\nexport async function installCommunityPlugin(params: InstallCommunityPluginParams): Promise<void> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (app.plugins.manifests[pluginId]) {\n    return;\n  }\n\n  const repo = await getCommunityPluginRepo(pluginId);\n  if (!repo) {\n    throw new Error(`Plugin '${pluginId}' was not found in the Obsidian community plugins registry.`);\n  }\n\n  const version = await getLatestReleaseVersion(repo);\n  const manifest = await getPluginManifest(repo, version);\n  await app.plugins.installPlugin(repo, version, manifest);\n}\n\n/**\n * Searches Obsidian's public community plugins registry, returning the id and display name of every\n * plugin whose id, name, author or description contains the query (case-insensitive). An empty query\n * matches every plugin.\n *\n * @param query - The search query.\n * @returns A {@link Promise} resolving to the matching plugins' {@link CommunityPluginSearchResult}s.\n */\nexport async function searchCommunityPlugins(query: string): Promise<CommunityPluginSearchResult[]> {\n  const entries = await getCommunityPluginEntries();\n  const normalizedQuery = query.toLowerCase();\n  return entries\n    .filter((entry) =>\n      entry.id.toLowerCase().includes(normalizedQuery)\n      || entry.name.toLowerCase().includes(normalizedQuery)\n      || entry.author.toLowerCase().includes(normalizedQuery)\n      || entry.description.toLowerCase().includes(normalizedQuery)\n    )\n    .map((entry) => ({\n      id: entry.id,\n      name: entry.name\n    }));\n}\n\n/**\n * Enables or disables a community plugin to match the desired state. Delegates to\n * {@link enableCommunityPlugin} / {@link disableCommunityPlugin}, so it is idempotent.\n *\n * @param params - The {@link ToggleEnableCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin matches the desired enabled state.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function toggleEnableCommunityPlugin(params: ToggleEnableCommunityPluginParams): Promise<void> {\n  if (params.isEnabled) {\n    await enableCommunityPlugin(params);\n  } else {\n    await disableCommunityPlugin(params);\n  }\n}\n\n/**\n * Installs or uninstalls a community plugin to match the desired state. Delegates to\n * {@link installCommunityPlugin} / {@link uninstallCommunityPlugin}, so it is idempotent.\n *\n * @param params - The {@link ToggleInstallCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin matches the desired installed state.\n * @throws If installing and the plugin is not listed in Obsidian's community plugins registry.\n */\nexport async function toggleInstallCommunityPlugin(params: ToggleInstallCommunityPluginParams): Promise<void> {\n  if (params.isInstalled) {\n    await installCommunityPlugin(params);\n  } else {\n    await uninstallCommunityPlugin(params);\n  }\n}\n\n/**\n * Uninstalls a community plugin if it is currently installed. Idempotent \u2014 a no-op when the plugin is\n * not installed.\n *\n * @param params - The {@link UninstallCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is uninstalled.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function uninstallCommunityPlugin(params: UninstallCommunityPluginParams): Promise<void> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (!app.plugins.manifests[pluginId]) {\n    return;\n  }\n  await app.plugins.uninstallPlugin(pluginId);\n}\n\nasync function fetchCommunityPluginEntries(): Promise<CommunityPluginEntry[]> {\n  const response = await requestUrl(COMMUNITY_PLUGINS_URL);\n  return response.json as CommunityPluginEntry[];\n}\n\nasync function getCommunityPluginEntries(): Promise<CommunityPluginEntry[]> {\n  const cache = getObsidianDevUtilsState<null | Promise<CommunityPluginEntry[]>>(COMMUNITY_PLUGINS_STATE_KEY, null);\n  cache.value ??= fetchCommunityPluginEntries();\n\n  try {\n    return await cache.value;\n  } catch (error) {\n    cache.value = null;\n    throw error;\n  }\n}\n\nasync function getPluginManifest(repo: string, version: string): Promise<PluginManifest> {\n  const response = await requestUrl(`https://github.com/${repo}/releases/download/${version}/manifest.json`);\n  return response.json as PluginManifest;\n}\n\nasync function resolveCommunityPluginId(ref: CommunityPluginRef): Promise<string> {\n  if ('pluginId' in ref) {\n    return ref.pluginId;\n  }\n\n  const entries = await getCommunityPluginEntries();\n  const entry = entries.find((candidate) => candidate.name === ref.pluginName);\n  if (!entry) {\n    throw new Error(`Plugin named '${ref.pluginName}' was not found in the Obsidian community plugins registry.`);\n  }\n  return entry.id;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/obsidian/community-plugins.d.cts

@@ -2,12 +2,128 @@
 /**
  * @file
  *
- * Resolves a community plugin's GitHub repository from Obsidian's public plugin registry.
+ * Resolves, searches and manages community plugins through Obsidian's public plugin registry and
+ * store-install path.
  *
  * Obsidian's `community-plugins.json` is the authoritative source that maps a plugin `id` to its
- * `owner/name` GitHub repository — the plugin manifest itself carries no repository. This is used to
- * locate a plugin's GitHub releases (e.g. to download its shipped demo-vault archive).
+ * `owner/name` GitHub repository — the plugin manifest itself carries no repository. This module uses
+ * it to search the registry, to locate a plugin's GitHub releases (e.g. to download its shipped
+ * demo-vault archive), and to install/uninstall/enable/disable an arbitrary community plugin — selected
+ * by either its `id` or its display `name` — via Obsidian's own store path (`app.plugins.installPlugin`
+ * + `enablePluginAndSave`), so any dev/deploy or tooling flow can reuse it.
  */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Selects a community plugin either by its id ({@link CommunityPluginByIdRef}) or by its display name
+ * ({@link CommunityPluginByNameRef}).
+ */
+export type CommunityPluginRef = CommunityPluginByIdRef | CommunityPluginByNameRef;
+/**
+ * A single result of {@link searchCommunityPlugins}.
+ */
+export interface CommunityPluginSearchResult {
+    /**
+     * The plugin id.
+     */
+    readonly id: string;
+    /**
+     * The plugin display name.
+     */
+    readonly name: string;
+}
+/**
+ * Parameters for {@link disableCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type DisableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;
+/**
+ * Parameters for {@link enableCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type EnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;
+/**
+ * Parameters for {@link installCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type InstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;
+/**
+ * Parameters for {@link toggleEnableCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type ToggleEnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginToggleEnableState;
+/**
+ * Parameters for {@link toggleInstallCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type ToggleInstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginToggleInstallState;
+/**
+ * Parameters for {@link uninstallCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type UninstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;
+/**
+ * Selects a community plugin by its id.
+ */
+interface CommunityPluginByIdRef {
+    /**
+     * The plugin id.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Selects a community plugin by its display name (as listed in Obsidian's community registry).
+ */
+interface CommunityPluginByNameRef {
+    /**
+     * The plugin display name.
+     */
+    readonly pluginName: string;
+}
+/**
+ * The Obsidian app instance a community-plugin operation runs against.
+ */
+interface CommunityPluginOperationContext {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+}
+/**
+ * The desired enabled state for {@link toggleEnableCommunityPlugin}.
+ */
+interface CommunityPluginToggleEnableState {
+    /**
+     * The desired enabled state: `true` enables the plugin, `false` disables it.
+     */
+    readonly isEnabled: boolean;
+}
+/**
+ * The desired installed state for {@link toggleInstallCommunityPlugin}.
+ */
+interface CommunityPluginToggleInstallState {
+    /**
+     * The desired installed state: `true` installs the plugin, `false` uninstalls it.
+     */
+    readonly isInstalled: boolean;
+}
+/**
+ * Disables a community plugin (persisting the change) if it is currently enabled. Idempotent — a no-op
+ * when the plugin is already disabled.
+ *
+ * @param params - The {@link DisableCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is disabled.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function disableCommunityPlugin(params: DisableCommunityPluginParams): Promise<void>;
+/**
+ * Enables a community plugin (persisting the change) if it is not already enabled. Idempotent — a no-op
+ * when the plugin is already enabled.
+ *
+ * @param params - The {@link EnableCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is enabled.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function enableCommunityPlugin(params: EnableCommunityPluginParams): Promise<void>;
 /**
  * Resolves the `owner/name` GitHub repository of a community plugin from Obsidian's public
  * `community-plugins.json` registry.
@@ -20,3 +136,59 @@
  * plugin is not listed in the registry.
  */
 export declare function getCommunityPluginRepo(pluginId: string): Promise<null | string>;
+/**
+ * Resolves the latest release version (the release `tag_name`, a bare version such as `1.2.3`) of a
+ * GitHub repository.
+ *
+ * @param repo - The `owner/name` GitHub repository.
+ * @returns A {@link Promise} resolving to the latest release version.
+ */
+export declare function getLatestReleaseVersion(repo: string): Promise<string>;
+/**
+ * Installs a community plugin from the official store if it is not already installed. Idempotent — a
+ * no-op when the plugin is already installed. Resolves the plugin's repository from Obsidian's
+ * community registry, reads the latest release version and its manifest, and installs it through
+ * Obsidian's own `installPlugin` path.
+ *
+ * @param params - The {@link InstallCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is installed.
+ * @throws If the plugin is not listed in Obsidian's community plugins registry.
+ */
+export declare function installCommunityPlugin(params: InstallCommunityPluginParams): Promise<void>;
+/**
+ * Searches Obsidian's public community plugins registry, returning the id and display name of every
+ * plugin whose id, name, author or description contains the query (case-insensitive). An empty query
+ * matches every plugin.
+ *
+ * @param query - The search query.
+ * @returns A {@link Promise} resolving to the matching plugins' {@link CommunityPluginSearchResult}s.
+ */
+export declare function searchCommunityPlugins(query: string): Promise<CommunityPluginSearchResult[]>;
+/**
+ * Enables or disables a community plugin to match the desired state. Delegates to
+ * {@link enableCommunityPlugin} / {@link disableCommunityPlugin}, so it is idempotent.
+ *
+ * @param params - The {@link ToggleEnableCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin matches the desired enabled state.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function toggleEnableCommunityPlugin(params: ToggleEnableCommunityPluginParams): Promise<void>;
+/**
+ * Installs or uninstalls a community plugin to match the desired state. Delegates to
+ * {@link installCommunityPlugin} / {@link uninstallCommunityPlugin}, so it is idempotent.
+ *
+ * @param params - The {@link ToggleInstallCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin matches the desired installed state.
+ * @throws If installing and the plugin is not listed in Obsidian's community plugins registry.
+ */
+export declare function toggleInstallCommunityPlugin(params: ToggleInstallCommunityPluginParams): Promise<void>;
+/**
+ * Uninstalls a community plugin if it is currently installed. Idempotent — a no-op when the plugin is
+ * not installed.
+ *
+ * @param params - The {@link UninstallCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is uninstalled.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function uninstallCommunityPlugin(params: UninstallCommunityPluginParams): Promise<void>;
+export {};

package/dist/lib/cjs/obsidian/components/component-ex.cjs

@@ -211,6 +211,23 @@ class ComponentEx extends import_obsidian.Component {
   onloadAsync() {
     return import_function.noopAsyncSingletonPromise;
   }
+  /**
+   * Registers a {@link Disposable} so it is disposed when this component unloads, and returns it unchanged.
+   *
+   * The recurring "tie a disposable to the component's lifecycle, then keep using it" idiom: the disposable is
+   * disposed on {@link Component.unload} (or earlier, if the caller disposes it directly — dispose is expected to
+   * be idempotent). Guard with {@link ensureLoaded} at the call site when registering before load would be unsafe.
+   *
+   * @typeParam TDisposable - The type of the disposable.
+   * @param disposable - The disposable to register.
+   * @returns The same disposable, for chaining.
+   */
+  registerDisposable(disposable) {
+    this.register(() => {
+      disposable[Symbol.dispose]();
+    });
+    return disposable;
+  }
   /**
    * Removes a child component.
    *
@@ -355,4 +372,4 @@ class ComponentEx extends import_obsidian.Component {
 0 && (module.exports = {
   ComponentEx
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/component-ex.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Extended Component\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { Component } from 'obsidian';\n\nimport { ErrorWrapper } from '../../error.ts';\nimport {\n  noop,\n  noopAsyncSingletonPromise\n} from '../../function.ts';\n\n/**\n * Extended Component\n */\n// eslint-disable-next-line obsidian-dev-utils/require-component-suffix -- Extended base class.\nexport class ComponentEx extends Component implements Disposable {\n  private readonly childrenSet = new Set<Component>();\n  private loadErrors: Error[] = [];\n  private loadPromise: null | Promise<void> = null;\n\n  /**\n   * Adds a child component.\n   *\n   * Mirrors the native `Component.addChild` contract: if this component is already loaded, the child is loaded\n   * immediately, so `child._loaded` is set before this method returns even when this component has async load logic.\n   * The child's async tail (if any) is sequenced into the load promise so a later {@link loadWithPromises} call awaits it.\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    this._children.push(component);\n    this.childrenSet.add(component);\n\n    if (this._loaded) {\n      this.appendEagerLoadStep(this.extractLoadPromisable(component));\n    }\n\n    return component;\n  }\n\n  /**\n   * Loads the component.\n   *\n   * @returns Despite the declared `void` return type, this method returns a {@link Promise} that resolves when the component is loaded or `null` if the component is fully synchronous.\n   */\n  public override load(): void {\n    if (this._loaded) {\n      return;\n    }\n\n    this._loaded = true;\n    this.resetLoadState();\n\n    this.onload();\n\n    const onloadAsyncPromise = this.onloadAsync();\n    if (onloadAsyncPromise !== noopAsyncSingletonPromise) {\n      this.appendEagerLoadStep(onloadAsyncPromise);\n    }\n\n    for (const child of this._children.slice()) {\n      this.appendSequentialLoadStep(() => this.extractLoadPromisable(child));\n    }\n\n    if (this.loadPromise) {\n      // eslint-disable-next-line @typescript-eslint/no-invalid-void-type, no-restricted-syntax -- We need to bypass type system to return `Promise<void>`.\n      return this.loadPromise as unknown as void;\n    }\n  }\n\n  /**\n   * Loads the component with promises.\n   *\n   * Unlike {@link load}, this method never rejects with an individual error: every failure raised by {@link onloadAsync}\n   * or a child's load is collected, and once everything settles the returned {@link Promise} rejects with a single\n   * {@link AggregateError} holding all of them. Non-`Error` throwables are normalized via {@link ErrorWrapper.create}.\n   *\n   * @returns A {@link Promise} that resolves when the component and its children finish loading, rejects with an {@link AggregateError} if any load step failed, or `null` if the component and its children don't use `async` logic and none failed synchronously.\n   */\n  public loadWithPromises(): null | Promise<void> {\n    this.load();\n\n    const loadPromise = this.loadPromise;\n    if (!loadPromise) {\n      if (this.loadErrors.length > 0) {\n        return Promise.reject(new AggregateError(this.loadErrors));\n      }\n      return null;\n    }\n\n    return loadPromise.then(() => {\n      if (this.loadErrors.length > 0) {\n        throw new AggregateError(this.loadErrors);\n      }\n    });\n  }\n\n  /**\n   * Asynchronously loads the component.\n   *\n   * Override to add async load logic, which is executed after {@link Component.onload}.\n   *\n   * @returns A {@link Promise} that resolves when the component is loaded.\n   */\n  public onloadAsync(): Promise<void> {\n    return noopAsyncSingletonPromise;\n  }\n\n  /**\n   * Removes a child component.\n   *\n   * @typeParam TComponent - The type of component to remove.\n   * @param component - The component instance to remove.\n   * @returns The removed component.\n   */\n  public override removeChild<TComponent extends Component>(component: TComponent): TComponent {\n    super.removeChild(component);\n    this.childrenSet.delete(component);\n    return component;\n  }\n\n  /**\n   * Disposes of the component.\n   */\n  public [Symbol.dispose](): void {\n    this.unload();\n  }\n\n  /**\n   * Ensures the component is loaded, throwing if it is not.\n   *\n   * Use this to guard public methods that register teardown-bearing resources (via {@link Component.register},\n   * {@link Component.registerEvent}, {@link Component.registerDomEvent}, etc.). Registering before load is unsafe:\n   * {@link Component.unload} is a no-op while the component is not loaded, so any teardown registered beforehand would\n   * never run if the component is unloaded without first being loaded.\n   *\n   * @throws An {@link Error} if the component is not loaded.\n   */\n  protected ensureLoaded(): void {\n    if (!this._loaded) {\n      throw new Error('Component is not loaded');\n    }\n  }\n\n  /**\n   * Sequences an already-started load step into the load promise.\n   *\n   * The step is presumed to have started synchronously (so any `_loaded` flag it sets is already visible); only the\n   * awaiting of its async tail is sequenced here.\n   *\n   * @param loadPromisable - The result of an already-started load step.\n   */\n  private appendEagerLoadStep(loadPromisable: null | Promisable<void>): void {\n    const captured = this.captureSettled(loadPromisable);\n    if (!captured) {\n      return;\n    }\n\n    const previous = this.loadPromise;\n    this.setLoadPromise(previous ? previous.then(() => captured) : captured);\n  }\n\n  /**\n   * Sequences a deferred load step into the load promise, running it only after previously-appended steps settle.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   */\n  private appendSequentialLoadStep(loadPromisableFn: () => null | Promisable<void>): void {\n    const previous = this.loadPromise;\n    if (previous) {\n      this.setLoadPromise(previous.then(() => this.runAndCapture(loadPromisableFn)));\n      return;\n    }\n\n    const captured = this.captureSync(loadPromisableFn);\n    if (captured) {\n      this.setLoadPromise(captured);\n    }\n  }\n\n  /**\n   * Records a load failure.\n   *\n   * A failure raised by a child {@link ComponentEx} is itself an {@link AggregateError}; it is recorded as-is so the\n   * grouping by child component is preserved (own failures stay flat, child-subtree failures stay nested).\n   *\n   * @param error - The thrown value to record.\n   */\n  private captureError(error: unknown): void {\n    this.loadErrors.push(ErrorWrapper.create(error));\n  }\n\n  /**\n   * Wraps an already-started load result so it never rejects: any failure is recorded into `loadErrors`.\n   *\n   * @param loadPromisable - The load result to observe.\n   * @returns A never-rejecting {@link Promise}, or `null` if the result is fully synchronous.\n   */\n  private captureSettled(loadPromisable: null | Promisable<void>): null | Promise<void> {\n    if (loadPromisable === null || loadPromisable === undefined) {\n      return null;\n    }\n\n    return Promise.resolve(loadPromisable).then(noop, (error: unknown) => {\n      this.captureError(error);\n    });\n  }\n\n  /**\n   * Runs a load step synchronously, recording a synchronous throw, and wraps any async tail so it never rejects.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   * @returns A never-rejecting {@link Promise}, or `null` if the step is fully synchronous.\n   */\n  private captureSync(loadPromisableFn: () => null | Promisable<void>): null | Promise<void> {\n    let loadPromisable: null | Promisable<void>;\n    try {\n      loadPromisable = loadPromisableFn();\n    } catch (error) {\n      this.captureError(error);\n      return null;\n    }\n\n    return this.captureSettled(loadPromisable);\n  }\n\n  private extractLoadPromisable(component: Component): null | Promisable<void> {\n    if (!this.childrenSet.has(component)) {\n      return null;\n    }\n    if (component instanceof ComponentEx) {\n      return component.loadWithPromises();\n    }\n    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression, @typescript-eslint/no-unnecessary-type-assertion -- It can be `Promise<void>` in runtime. Want explicitly cast to show we know it may be promise, despite the declared type `void`.\n    return component.load() as Promisable<void>;\n  }\n\n  private resetLoadState(): void {\n    this.loadErrors = [];\n    this.loadPromise = null;\n  }\n\n  /**\n   * Runs a deferred load step, recording a synchronous throw or an async rejection without ever re-throwing.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   */\n  private async runAndCapture(loadPromisableFn: () => null | Promisable<void>): Promise<void> {\n    try {\n      await (loadPromisableFn() ?? undefined);\n    } catch (error) {\n      this.captureError(error);\n    }\n  }\n\n  private setLoadPromise(loadPromise: Promise<void>): void {\n    const loadPromiseWithReset: Promise<void> = loadPromise.then(() => {\n      if (this.loadPromise === loadPromiseWithReset) {\n        this.loadPromise = null;\n      }\n    });\n    this.loadPromise = loadPromiseWithReset;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/component-ex.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Extended Component\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { Component } from 'obsidian';\n\nimport { ErrorWrapper } from '../../error.ts';\nimport {\n  noop,\n  noopAsyncSingletonPromise\n} from '../../function.ts';\n\n/**\n * Extended Component\n */\n// eslint-disable-next-line obsidian-dev-utils/require-component-suffix -- Extended base class.\nexport class ComponentEx extends Component implements Disposable {\n  private readonly childrenSet = new Set<Component>();\n  private loadErrors: Error[] = [];\n  private loadPromise: null | Promise<void> = null;\n\n  /**\n   * Adds a child component.\n   *\n   * Mirrors the native `Component.addChild` contract: if this component is already loaded, the child is loaded\n   * immediately, so `child._loaded` is set before this method returns even when this component has async load logic.\n   * The child's async tail (if any) is sequenced into the load promise so a later {@link loadWithPromises} call awaits it.\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    this._children.push(component);\n    this.childrenSet.add(component);\n\n    if (this._loaded) {\n      this.appendEagerLoadStep(this.extractLoadPromisable(component));\n    }\n\n    return component;\n  }\n\n  /**\n   * Loads the component.\n   *\n   * @returns Despite the declared `void` return type, this method returns a {@link Promise} that resolves when the component is loaded or `null` if the component is fully synchronous.\n   */\n  public override load(): void {\n    if (this._loaded) {\n      return;\n    }\n\n    this._loaded = true;\n    this.resetLoadState();\n\n    this.onload();\n\n    const onloadAsyncPromise = this.onloadAsync();\n    if (onloadAsyncPromise !== noopAsyncSingletonPromise) {\n      this.appendEagerLoadStep(onloadAsyncPromise);\n    }\n\n    for (const child of this._children.slice()) {\n      this.appendSequentialLoadStep(() => this.extractLoadPromisable(child));\n    }\n\n    if (this.loadPromise) {\n      // eslint-disable-next-line @typescript-eslint/no-invalid-void-type, no-restricted-syntax -- We need to bypass type system to return `Promise<void>`.\n      return this.loadPromise as unknown as void;\n    }\n  }\n\n  /**\n   * Loads the component with promises.\n   *\n   * Unlike {@link load}, this method never rejects with an individual error: every failure raised by {@link onloadAsync}\n   * or a child's load is collected, and once everything settles the returned {@link Promise} rejects with a single\n   * {@link AggregateError} holding all of them. Non-`Error` throwables are normalized via {@link ErrorWrapper.create}.\n   *\n   * @returns A {@link Promise} that resolves when the component and its children finish loading, rejects with an {@link AggregateError} if any load step failed, or `null` if the component and its children don't use `async` logic and none failed synchronously.\n   */\n  public loadWithPromises(): null | Promise<void> {\n    this.load();\n\n    const loadPromise = this.loadPromise;\n    if (!loadPromise) {\n      if (this.loadErrors.length > 0) {\n        return Promise.reject(new AggregateError(this.loadErrors));\n      }\n      return null;\n    }\n\n    return loadPromise.then(() => {\n      if (this.loadErrors.length > 0) {\n        throw new AggregateError(this.loadErrors);\n      }\n    });\n  }\n\n  /**\n   * Asynchronously loads the component.\n   *\n   * Override to add async load logic, which is executed after {@link Component.onload}.\n   *\n   * @returns A {@link Promise} that resolves when the component is loaded.\n   */\n  public onloadAsync(): Promise<void> {\n    return noopAsyncSingletonPromise;\n  }\n\n  /**\n   * Registers a {@link Disposable} so it is disposed when this component unloads, and returns it unchanged.\n   *\n   * The recurring \"tie a disposable to the component's lifecycle, then keep using it\" idiom: the disposable is\n   * disposed on {@link Component.unload} (or earlier, if the caller disposes it directly \u2014 dispose is expected to\n   * be idempotent). Guard with {@link ensureLoaded} at the call site when registering before load would be unsafe.\n   *\n   * @typeParam TDisposable - The type of the disposable.\n   * @param disposable - The disposable to register.\n   * @returns The same disposable, for chaining.\n   */\n  public registerDisposable<TDisposable extends Disposable>(disposable: TDisposable): TDisposable {\n    this.register(() => {\n      disposable[Symbol.dispose]();\n    });\n    return disposable;\n  }\n\n  /**\n   * Removes a child component.\n   *\n   * @typeParam TComponent - The type of component to remove.\n   * @param component - The component instance to remove.\n   * @returns The removed component.\n   */\n  public override removeChild<TComponent extends Component>(component: TComponent): TComponent {\n    super.removeChild(component);\n    this.childrenSet.delete(component);\n    return component;\n  }\n\n  /**\n   * Disposes of the component.\n   */\n  public [Symbol.dispose](): void {\n    this.unload();\n  }\n\n  /**\n   * Ensures the component is loaded, throwing if it is not.\n   *\n   * Use this to guard public methods that register teardown-bearing resources (via {@link Component.register},\n   * {@link Component.registerEvent}, {@link Component.registerDomEvent}, etc.). Registering before load is unsafe:\n   * {@link Component.unload} is a no-op while the component is not loaded, so any teardown registered beforehand would\n   * never run if the component is unloaded without first being loaded.\n   *\n   * @throws An {@link Error} if the component is not loaded.\n   */\n  protected ensureLoaded(): void {\n    if (!this._loaded) {\n      throw new Error('Component is not loaded');\n    }\n  }\n\n  /**\n   * Sequences an already-started load step into the load promise.\n   *\n   * The step is presumed to have started synchronously (so any `_loaded` flag it sets is already visible); only the\n   * awaiting of its async tail is sequenced here.\n   *\n   * @param loadPromisable - The result of an already-started load step.\n   */\n  private appendEagerLoadStep(loadPromisable: null | Promisable<void>): void {\n    const captured = this.captureSettled(loadPromisable);\n    if (!captured) {\n      return;\n    }\n\n    const previous = this.loadPromise;\n    this.setLoadPromise(previous ? previous.then(() => captured) : captured);\n  }\n\n  /**\n   * Sequences a deferred load step into the load promise, running it only after previously-appended steps settle.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   */\n  private appendSequentialLoadStep(loadPromisableFn: () => null | Promisable<void>): void {\n    const previous = this.loadPromise;\n    if (previous) {\n      this.setLoadPromise(previous.then(() => this.runAndCapture(loadPromisableFn)));\n      return;\n    }\n\n    const captured = this.captureSync(loadPromisableFn);\n    if (captured) {\n      this.setLoadPromise(captured);\n    }\n  }\n\n  /**\n   * Records a load failure.\n   *\n   * A failure raised by a child {@link ComponentEx} is itself an {@link AggregateError}; it is recorded as-is so the\n   * grouping by child component is preserved (own failures stay flat, child-subtree failures stay nested).\n   *\n   * @param error - The thrown value to record.\n   */\n  private captureError(error: unknown): void {\n    this.loadErrors.push(ErrorWrapper.create(error));\n  }\n\n  /**\n   * Wraps an already-started load result so it never rejects: any failure is recorded into `loadErrors`.\n   *\n   * @param loadPromisable - The load result to observe.\n   * @returns A never-rejecting {@link Promise}, or `null` if the result is fully synchronous.\n   */\n  private captureSettled(loadPromisable: null | Promisable<void>): null | Promise<void> {\n    if (loadPromisable === null || loadPromisable === undefined) {\n      return null;\n    }\n\n    return Promise.resolve(loadPromisable).then(noop, (error: unknown) => {\n      this.captureError(error);\n    });\n  }\n\n  /**\n   * Runs a load step synchronously, recording a synchronous throw, and wraps any async tail so it never rejects.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   * @returns A never-rejecting {@link Promise}, or `null` if the step is fully synchronous.\n   */\n  private captureSync(loadPromisableFn: () => null | Promisable<void>): null | Promise<void> {\n    let loadPromisable: null | Promisable<void>;\n    try {\n      loadPromisable = loadPromisableFn();\n    } catch (error) {\n      this.captureError(error);\n      return null;\n    }\n\n    return this.captureSettled(loadPromisable);\n  }\n\n  private extractLoadPromisable(component: Component): null | Promisable<void> {\n    if (!this.childrenSet.has(component)) {\n      return null;\n    }\n    if (component instanceof ComponentEx) {\n      return component.loadWithPromises();\n    }\n    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression, @typescript-eslint/no-unnecessary-type-assertion -- It can be `Promise<void>` in runtime. Want explicitly cast to show we know it may be promise, despite the declared type `void`.\n    return component.load() as Promisable<void>;\n  }\n\n  private resetLoadState(): void {\n    this.loadErrors = [];\n    this.loadPromise = null;\n  }\n\n  /**\n   * Runs a deferred load step, recording a synchronous throw or an async rejection without ever re-throwing.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   */\n  private async runAndCapture(loadPromisableFn: () => null | Promisable<void>): Promise<void> {\n    try {\n      await (loadPromisableFn() ?? undefined);\n    } catch (error) {\n      this.captureError(error);\n    }\n  }\n\n  private setLoadPromise(loadPromise: Promise<void>): void {\n    const loadPromiseWithReset: Promise<void> = loadPromise.then(() => {\n      if (this.loadPromise === loadPromiseWithReset) {\n        this.loadPromise = null;\n      }\n    });\n    this.loadPromise = loadPromiseWithReset;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,sBAA0B;AAE1B,mBAA6B;AAC7B,sBAGO;AAMA,MAAM,oBAAoB,0BAAgC;AAAA,EAC9C,cAAc,oBAAI,IAAe;AAAA,EAC1C,aAAsB,CAAC;AAAA,EACvB,cAAoC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAa5B,SAAuC,WAAmC;AACxF,SAAK,UAAU,KAAK,SAAS;AAC7B,SAAK,YAAY,IAAI,SAAS;AAE9B,QAAI,KAAK,SAAS;AAChB,WAAK,oBAAoB,KAAK,sBAAsB,SAAS,CAAC;AAAA,IAChE;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOgB,OAAa;AAC3B,QAAI,KAAK,SAAS;AAChB;AAAA,IACF;AAEA,SAAK,UAAU;AACf,SAAK,eAAe;AAEpB,SAAK,OAAO;AAEZ,UAAM,qBAAqB,KAAK,YAAY;AAC5C,QAAI,uBAAuB,2CAA2B;AACpD,WAAK,oBAAoB,kBAAkB;AAAA,IAC7C;AAEA,eAAW,SAAS,KAAK,UAAU,MAAM,GAAG;AAC1C,WAAK,yBAAyB,MAAM,KAAK,sBAAsB,KAAK,CAAC;AAAA,IACvE;AAEA,QAAI,KAAK,aAAa;AAEpB,aAAO,KAAK;AAAA,IACd;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,mBAAyC;AAC9C,SAAK,KAAK;AAEV,UAAM,cAAc,KAAK;AACzB,QAAI,CAAC,aAAa;AAChB,UAAI,KAAK,WAAW,SAAS,GAAG;AAC9B,eAAO,QAAQ,OAAO,IAAI,eAAe,KAAK,UAAU,CAAC;AAAA,MAC3D;AACA,aAAO;AAAA,IACT;AAEA,WAAO,YAAY,KAAK,MAAM;AAC5B,UAAI,KAAK,WAAW,SAAS,GAAG;AAC9B,cAAM,IAAI,eAAe,KAAK,UAAU;AAAA,MAC1C;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAA6B;AAClC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,mBAAmD,YAAsC;AAC9F,SAAK,SAAS,MAAM;AAClB,iBAAW,OAAO,OAAO,EAAE;AAAA,IAC7B,CAAC;AACD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASgB,YAA0C,WAAmC;AAC3F,UAAM,YAAY,SAAS;AAC3B,SAAK,YAAY,OAAO,SAAS;AACjC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,CAAQ,OAAO,OAAO,IAAU;AAC9B,SAAK,OAAO;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYU,eAAqB;AAC7B,QAAI,CAAC,KAAK,SAAS;AACjB,YAAM,IAAI,MAAM,yBAAyB;AAAA,IAC3C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUQ,oBAAoB,gBAA+C;AACzE,UAAM,WAAW,KAAK,eAAe,cAAc;AACnD,QAAI,CAAC,UAAU;AACb;AAAA,IACF;AAEA,UAAM,WAAW,KAAK;AACtB,SAAK,eAAe,WAAW,SAAS,KAAK,MAAM,QAAQ,IAAI,QAAQ;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,yBAAyB,kBAAuD;AACtF,UAAM,WAAW,KAAK;AACtB,QAAI,UAAU;AACZ,WAAK,eAAe,SAAS,KAAK,MAAM,KAAK,cAAc,gBAAgB,CAAC,CAAC;AAC7E;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,YAAY,gBAAgB;AAClD,QAAI,UAAU;AACZ,WAAK,eAAe,QAAQ;AAAA,IAC9B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUQ,aAAa,OAAsB;AACzC,SAAK,WAAW,KAAK,0BAAa,OAAO,KAAK,CAAC;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,eAAe,gBAA+D;AACpF,QAAI,mBAAmB,QAAQ,mBAAmB,QAAW;AAC3D,aAAO;AAAA,IACT;AAEA,WAAO,QAAQ,QAAQ,cAAc,EAAE,KAAK,sBAAM,CAAC,UAAmB;AACpE,WAAK,aAAa,KAAK;AAAA,IACzB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,YAAY,kBAAuE;AACzF,QAAI;AACJ,QAAI;AACF,uBAAiB,iBAAiB;AAAA,IACpC,SAAS,OAAO;AACd,WAAK,aAAa,KAAK;AACvB,aAAO;AAAA,IACT;AAEA,WAAO,KAAK,eAAe,cAAc;AAAA,EAC3C;AAAA,EAEQ,sBAAsB,WAA+C;AAC3E,QAAI,CAAC,KAAK,YAAY,IAAI,SAAS,GAAG;AACpC,aAAO;AAAA,IACT;AACA,QAAI,qBAAqB,aAAa;AACpC,aAAO,UAAU,iBAAiB;AAAA,IACpC;AAEA,WAAO,UAAU,KAAK;AAAA,EACxB;AAAA,EAEQ,iBAAuB;AAC7B,SAAK,aAAa,CAAC;AACnB,SAAK,cAAc;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAc,cAAc,kBAAgE;AAC1F,QAAI;AACF,aAAO,iBAAiB,KAAK;AAAA,IAC/B,SAAS,OAAO;AACd,WAAK,aAAa,KAAK;AAAA,IACzB;AAAA,EACF;AAAA,EAEQ,eAAe,aAAkC;AACvD,UAAM,uBAAsC,YAAY,KAAK,MAAM;AACjE,UAAI,KAAK,gBAAgB,sBAAsB;AAC7C,aAAK,cAAc;AAAA,MACrB;AAAA,IACF,CAAC;AACD,SAAK,cAAc;AAAA,EACrB;AACF;",
  "names": []
}


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

@@ -48,6 +48,18 @@ export declare class ComponentEx extends Component implements Disposable {
      * @returns A {@link Promise} that resolves when the component is loaded.
      */
     onloadAsync(): Promise<void>;
+    /**
+     * Registers a {@link Disposable} so it is disposed when this component unloads, and returns it unchanged.
+     *
+     * The recurring "tie a disposable to the component's lifecycle, then keep using it" idiom: the disposable is
+     * disposed on {@link Component.unload} (or earlier, if the caller disposes it directly — dispose is expected to
+     * be idempotent). Guard with {@link ensureLoaded} at the call site when registering before load would be unsafe.
+     *
+     * @typeParam TDisposable - The type of the disposable.
+     * @param disposable - The disposable to register.
+     * @returns The same disposable, for chaining.
+     */
+    registerDisposable<TDisposable extends Disposable>(disposable: TDisposable): TDisposable;
     /**
      * Removes a child component.
      *

package/dist/lib/cjs/obsidian/components/menu-event-registrar-component.cjs

@@ -128,6 +128,7 @@ __export(menu_event_registrar_component_exports, {
   MenuEventRegistrarComponent: () => MenuEventRegistrarComponent
 });
 module.exports = __toCommonJS(menu_event_registrar_component_exports);
+var import_events = require('../events.cjs');
 var import_component_ex = require('./component-ex.cjs');
 class MenuEventRegistrarComponent extends import_component_ex.ComponentEx {
   /**
@@ -144,32 +145,35 @@ class MenuEventRegistrarComponent extends import_component_ex.ComponentEx {
    * 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 (or on component unload).
    */
   registerEditorMenuEventHandler(handler) {
     this.ensureLoaded();
-    this.registerEvent(this.app.workspace.on("editor-menu", handler));
+    return this.registerDisposable(new import_events.EventRefDisposable(this.app.workspace.on("editor-menu", handler)));
   }
   /**
    * 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 (or on component unload).
    */
   registerFileMenuEventHandler(handler) {
     this.ensureLoaded();
-    this.registerEvent(this.app.workspace.on("file-menu", handler));
+    return this.registerDisposable(new import_events.EventRefDisposable(this.app.workspace.on("file-menu", handler)));
   }
   /**
    * 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 (or on component unload).
    */
   registerFilesMenuEventHandler(handler) {
     this.ensureLoaded();
-    this.registerEvent(this.app.workspace.on("files-menu", handler));
+    return this.registerDisposable(new import_events.EventRefDisposable(this.app.workspace.on("files-menu", handler)));
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MenuEventRegistrarComponent
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/components/menu-event-registrar-component.d.cts

@@ -5,6 +5,7 @@
  * Registers menu event handlers with Obsidian's workspace, supporting editor, file, and multi-file context menus.
  */
 import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { DisposableEx } from '../../disposable.cjs';
 import type { EditorMenuEventHandler, FileMenuEventHandler, FilesMenuEventHandler, MenuEventRegistrar } from '../menu-event-registrar.cjs';
 import { ComponentEx } from './component-ex.cjs';
 /**
@@ -24,18 +25,21 @@ export declare class MenuEventRegistrarComponent extends ComponentEx implements
      * 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 (or on component unload).
      */
-    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 (or on component unload).
      */
-    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 (or on component unload).
      */
-    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): void;
+    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): DisposableEx;
 }