obsidian-dev-utils 86.1.3 → 87.0.0

package/dist/lib/esm/obsidian/command-handlers/command-handler-component.d.mts

@@ -4,6 +4,7 @@
  *
  * Component that registers {@link CommandHandler}s with Obsidian and ties their removal to its lifecycle.
  */
+import type { DisposableEx } from '../../disposable.mjs';
 import type { ActiveFileProvider } from '../active-file-provider.mjs';
 import type { CommandRegistrar } from '../command-registrar.mjs';
 import type { MenuEventRegistrar } from '../menu-event-registrar.mjs';
@@ -19,8 +20,9 @@ interface CommandHandlerComponentConstructorParams {
  * Registers {@link CommandHandler}s with Obsidian and manages their lifecycle.
  *
  * Call {@link registerCommandHandlers} to register a batch of handlers on demand (as many times as
- * needed while the component is alive); dispose the returned {@link Disposable} to unregister exactly
- * those handlers, or let the component unload to remove every command still registered through it.
+ * needed while the component is alive); dispose the returned {@link DisposableEx} to unregister exactly
+ * those handlers — including any menu events they registered — or let the component unload to remove every
+ * command still registered through it.
  */
 export declare class CommandHandlerComponent extends ComponentEx {
     /**
@@ -46,14 +48,15 @@ export declare class CommandHandlerComponent extends ComponentEx {
      */
     constructor(params: CommandHandlerComponentConstructorParams);
     /**
-     * Registers the given command handlers with Obsidian and provides each its runtime registration
-     * context. Each handler's command is added immediately; the returned {@link Disposable} removes the
-     * commands registered by this call when disposed. Any command still registered when the component
-     * unloads is removed automatically.
+     * Registers the given command handlers with Obsidian and provides each its own runtime registration
+     * context. Each handler's command is added immediately; the returned {@link DisposableEx} removes the
+     * commands registered by this call — and any menu events those handlers registered via their context's
+     * {@link MenuEventRegistrar} — when disposed. Any command still registered when the component unloads is
+     * removed automatically.
      *
      * @param commandHandlers - The command handlers to register.
-     * @returns A {@link Disposable} that unregisters the handlers passed to this call.
+     * @returns A {@link DisposableEx} that unregisters the handlers (commands + menu events) passed to this call.
      */
-    registerCommandHandlers(commandHandlers: CommandHandler[]): Disposable;
+    registerCommandHandlers(commandHandlers: CommandHandler[]): DisposableEx;
 }
 export {};

package/dist/lib/esm/obsidian/command-handlers/command-handler-component.mjs

@@ -25,9 +25,40 @@ import { invokeAsyncSafely } from "../../async.mjs";
 import {
   CallbackDisposable,
   CombineDisposable,
-  MultipleDisposeBehavior
+  DisposableBase
 } from "../../disposable.mjs";
 import { ComponentEx } from "../components/component-ex.mjs";
+class CommandMenuEventScope extends DisposableBase {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  inner;
+  disposables = [];
+  registerEditorMenuEventHandler(handler) {
+    return this.collect(this.inner.registerEditorMenuEventHandler(handler));
+  }
+  registerFileMenuEventHandler(handler) {
+    return this.collect(this.inner.registerFileMenuEventHandler(handler));
+  }
+  registerFilesMenuEventHandler(handler) {
+    return this.collect(this.inner.registerFilesMenuEventHandler(handler));
+  }
+  performDispose() {
+    for (const disposable of this.disposables) {
+      disposable.dispose();
+    }
+    this.disposables.length = 0;
+  }
+  collect(disposable) {
+    if (this.isDisposed) {
+      disposable.dispose();
+    } else {
+      this.disposables.push(disposable);
+    }
+    return disposable;
+  }
+}
 class CommandHandlerComponent extends ComponentEx {
   /**
    * Provider for accessing the currently active file.
@@ -58,44 +89,40 @@ class CommandHandlerComponent extends ComponentEx {
     this.pluginName = params.pluginName;
   }
   /**
-   * Registers the given command handlers with Obsidian and provides each its runtime registration
-   * context. Each handler's command is added immediately; the returned {@link Disposable} removes the
-   * commands registered by this call when disposed. Any command still registered when the component
-   * unloads is removed automatically.
+   * Registers the given command handlers with Obsidian and provides each its own runtime registration
+   * context. Each handler's command is added immediately; the returned {@link DisposableEx} removes the
+   * commands registered by this call — and any menu events those handlers registered via their context's
+   * {@link MenuEventRegistrar} — when disposed. Any command still registered when the component unloads is
+   * removed automatically.
    *
    * @param commandHandlers - The command handlers to register.
-   * @returns A {@link Disposable} that unregisters the handlers passed to this call.
+   * @returns A {@link DisposableEx} that unregisters the handlers (commands + menu events) passed to this call.
    */
   registerCommandHandlers(commandHandlers) {
-    const context = {
-      activeFileProvider: this.activeFileProvider,
-      menuEventRegistrar: this.menuEventRegistrar,
-      pluginName: this.pluginName
-    };
     const disposables = [];
     for (const commandHandler of commandHandlers) {
       const command = commandHandler.buildCommand();
       const commandId = command.id;
       this.commandRegistrar.addCommand(command);
+      const menuEventScope = new CommandMenuEventScope(this.menuEventRegistrar);
+      const context = {
+        activeFileProvider: this.activeFileProvider,
+        menuEventRegistrar: menuEventScope,
+        pluginName: this.pluginName
+      };
       const disposable = new CallbackDisposable({
         callback: () => {
           this.commandRegistrar.removeCommand(commandId);
-        },
-        multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
-      });
-      disposables.push(disposable);
-      this.register(() => {
-        disposable.dispose();
+          menuEventScope.dispose();
+        }
       });
+      disposables.push(this.registerDisposable(disposable));
       invokeAsyncSafely(() => commandHandler.onRegistered(context));
     }
-    return new CombineDisposable({
-      disposables,
-      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
-    });
+    return new CombineDisposable({ disposables });
   }
 }
 export {
   CommandHandlerComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/command-handlers/command-handler-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that registers {@link CommandHandler}s with Obsidian and ties their removal to its lifecycle.\n */\n\nimport type { DisposableEx } from '../../disposable.ts';\nimport type { ActiveFileProvider } from '../active-file-provider.ts';\nimport type { CommandRegistrar } from '../command-registrar.ts';\nimport type {\n  EditorMenuEventHandler,\n  FileMenuEventHandler,\n  FilesMenuEventHandler,\n  MenuEventRegistrar\n} from '../menu-event-registrar.ts';\nimport type {\n  CommandHandler,\n  CommandHandlerRegistrationContext\n} from './command-handler.ts';\n\nimport { invokeAsyncSafely } from '../../async.ts';\nimport {\n  CallbackDisposable,\n  CombineDisposable,\n  DisposableBase\n} from '../../disposable.ts';\nimport { ComponentEx } from '../components/component-ex.ts';\n\ninterface CommandHandlerComponentConstructorParams {\n  readonly activeFileProvider: ActiveFileProvider;\n  readonly commandRegistrar: CommandRegistrar;\n  readonly menuEventRegistrar: MenuEventRegistrar;\n  readonly pluginName: string;\n}\n\n/**\n * A per-command {@link MenuEventRegistrar} that delegates to a shared registrar while collecting the\n * {@link DisposableEx} each registration returns, so disposing this scope unregisters exactly that command's\n * menu events. Because {@link CommandHandler.onRegistered} runs fire-and-forget (it may register menu events\n * after this scope has already been disposed), a registration that arrives post-dispose is disposed immediately\n * instead of leaking.\n */\nclass CommandMenuEventScope extends DisposableBase implements MenuEventRegistrar {\n  private readonly disposables: DisposableEx[] = [];\n\n  public constructor(private readonly inner: MenuEventRegistrar) {\n    super();\n  }\n\n  public registerEditorMenuEventHandler(handler: EditorMenuEventHandler): DisposableEx {\n    return this.collect(this.inner.registerEditorMenuEventHandler(handler));\n  }\n\n  public registerFileMenuEventHandler(handler: FileMenuEventHandler): DisposableEx {\n    return this.collect(this.inner.registerFileMenuEventHandler(handler));\n  }\n\n  public registerFilesMenuEventHandler(handler: FilesMenuEventHandler): DisposableEx {\n    return this.collect(this.inner.registerFilesMenuEventHandler(handler));\n  }\n\n  protected override performDispose(): void {\n    for (const disposable of this.disposables) {\n      disposable.dispose();\n    }\n    this.disposables.length = 0;\n  }\n\n  private collect(disposable: DisposableEx): DisposableEx {\n    if (this.isDisposed) {\n      disposable.dispose();\n    } else {\n      this.disposables.push(disposable);\n    }\n\n    return disposable;\n  }\n}\n\n/**\n * Registers {@link CommandHandler}s with Obsidian and manages their lifecycle.\n *\n * Call {@link registerCommandHandlers} to register a batch of handlers on demand (as many times as\n * needed while the component is alive); dispose the returned {@link DisposableEx} to unregister exactly\n * those handlers \u2014 including any menu events they registered \u2014 or let the component unload to remove every\n * command still registered through it.\n */\nexport class CommandHandlerComponent extends ComponentEx {\n  /**\n   * Provider for accessing the currently active file.\n   */\n  protected readonly activeFileProvider: ActiveFileProvider;\n\n  /**\n   * Registrar used to add and remove commands with Obsidian.\n   */\n  protected readonly commandRegistrar: CommandRegistrar;\n\n  /**\n   * Registrar for menu event handlers.\n   */\n  protected readonly menuEventRegistrar: MenuEventRegistrar;\n\n  /**\n   * The name of the plugin that owns the commands.\n   */\n  protected readonly pluginName: string;\n\n  /**\n   * Creates a new command handler component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: CommandHandlerComponentConstructorParams) {\n    super();\n    this.activeFileProvider = params.activeFileProvider;\n    this.menuEventRegistrar = params.menuEventRegistrar;\n    this.commandRegistrar = params.commandRegistrar;\n    this.pluginName = params.pluginName;\n  }\n\n  /**\n   * Registers the given command handlers with Obsidian and provides each its own runtime registration\n   * context. Each handler's command is added immediately; the returned {@link DisposableEx} removes the\n   * commands registered by this call \u2014 and any menu events those handlers registered via their context's\n   * {@link MenuEventRegistrar} \u2014 when disposed. Any command still registered when the component unloads is\n   * removed automatically.\n   *\n   * @param commandHandlers - The command handlers to register.\n   * @returns A {@link DisposableEx} that unregisters the handlers (commands + menu events) passed to this call.\n   */\n  public registerCommandHandlers(commandHandlers: CommandHandler[]): DisposableEx {\n    const disposables: Disposable[] = [];\n    for (const commandHandler of commandHandlers) {\n      const command = commandHandler.buildCommand();\n      // Capture the id before registering. `Plugin.addCommand` mutates `command.id` (prefixing it with\n      // `this.manifest.id`), while `Plugin.removeCommand` re-prefixes \u2014 so removal needs the original id.\n      // Reading `command.id` after `addCommand` would double-prefix it, so the command is never removed.\n      const commandId = command.id;\n      this.commandRegistrar.addCommand(command);\n\n      // Each command gets its own registration context with a per-command menu-event scope, so disposing one\n      // Command tears down its own menu events without affecting the others.\n      const menuEventScope = new CommandMenuEventScope(this.menuEventRegistrar);\n      const context: CommandHandlerRegistrationContext = {\n        activeFileProvider: this.activeFileProvider,\n        menuEventRegistrar: menuEventScope,\n        pluginName: this.pluginName\n      };\n\n      const disposable = new CallbackDisposable({\n        callback: (): void => {\n          this.commandRegistrar.removeCommand(commandId);\n          menuEventScope.dispose();\n        }\n      });\n      // Tie removal to the component's unload, so a command never outlives the component.\n      disposables.push(this.registerDisposable(disposable));\n      invokeAsyncSafely(() => commandHandler.onRegistered(context));\n    }\n\n    return new CombineDisposable({ disposables });\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAoBA,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,mBAAmB;AAgB5B,MAAM,8BAA8B,eAA6C;AAAA,EAGxE,YAA6B,OAA2B;AAC7D,UAAM;AAD4B;AAAA,EAEpC;AAAA,EAFoC;AAAA,EAFnB,cAA8B,CAAC;AAAA,EAMzC,+BAA+B,SAA+C;AACnF,WAAO,KAAK,QAAQ,KAAK,MAAM,+BAA+B,OAAO,CAAC;AAAA,EACxE;AAAA,EAEO,6BAA6B,SAA6C;AAC/E,WAAO,KAAK,QAAQ,KAAK,MAAM,6BAA6B,OAAO,CAAC;AAAA,EACtE;AAAA,EAEO,8BAA8B,SAA8C;AACjF,WAAO,KAAK,QAAQ,KAAK,MAAM,8BAA8B,OAAO,CAAC;AAAA,EACvE;AAAA,EAEmB,iBAAuB;AACxC,eAAW,cAAc,KAAK,aAAa;AACzC,iBAAW,QAAQ;AAAA,IACrB;AACA,SAAK,YAAY,SAAS;AAAA,EAC5B;AAAA,EAEQ,QAAQ,YAAwC;AACtD,QAAI,KAAK,YAAY;AACnB,iBAAW,QAAQ;AAAA,IACrB,OAAO;AACL,WAAK,YAAY,KAAK,UAAU;AAAA,IAClC;AAEA,WAAO;AAAA,EACT;AACF;AAUO,MAAM,gCAAgC,YAAY;AAAA;AAAA;AAAA;AAAA,EAIpC;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOZ,YAAY,QAAkD;AACnE,UAAM;AACN,SAAK,qBAAqB,OAAO;AACjC,SAAK,qBAAqB,OAAO;AACjC,SAAK,mBAAmB,OAAO;AAC/B,SAAK,aAAa,OAAO;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,wBAAwB,iBAAiD;AAC9E,UAAM,cAA4B,CAAC;AACnC,eAAW,kBAAkB,iBAAiB;AAC5C,YAAM,UAAU,eAAe,aAAa;AAI5C,YAAM,YAAY,QAAQ;AAC1B,WAAK,iBAAiB,WAAW,OAAO;AAIxC,YAAM,iBAAiB,IAAI,sBAAsB,KAAK,kBAAkB;AACxE,YAAM,UAA6C;AAAA,QACjD,oBAAoB,KAAK;AAAA,QACzB,oBAAoB;AAAA,QACpB,YAAY,KAAK;AAAA,MACnB;AAEA,YAAM,aAAa,IAAI,mBAAmB;AAAA,QACxC,UAAU,MAAY;AACpB,eAAK,iBAAiB,cAAc,SAAS;AAC7C,yBAAe,QAAQ;AAAA,QACzB;AAAA,MACF,CAAC;AAED,kBAAY,KAAK,KAAK,mBAAmB,UAAU,CAAC;AACpD,wBAAkB,MAAM,eAAe,aAAa,OAAO,CAAC;AAAA,IAC9D;AAEA,WAAO,IAAI,kBAAkB,EAAE,YAAY,CAAC;AAAA,EAC9C;AACF;",
  "names": []
}


package/dist/lib/esm/obsidian/command-handlers/open-demo-vault-command-handler.mjs

@@ -55,7 +55,7 @@ class OpenDemoVaultCommandHandler extends GlobalCommandHandler {
    * Executes the command, opening the plugin's demo vault.
    */
   async execute() {
-    const { openDemoVault } = await import("../desktop-demo-vault-opener.ts");
+    const { openDemoVault } = await import("../desktop-demo-vault-opener.mjs");
     await openDemoVault({
       app: this.app,
       manifest: this.manifest,

package/dist/lib/esm/obsidian/community-plugins.d.mts

@@ -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';
+/**
+ * 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/esm/obsidian/community-plugins.mjs

@@ -25,24 +25,116 @@ import { requestUrl } from "obsidian";
 import { getObsidianDevUtilsState } from "../obsidian-dev-utils-state.mjs";
 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 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 requestUrl(COMMUNITY_PLUGINS_URL);
+  return response.json;
+}
+async function getCommunityPluginEntries() {
   const cache = 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 requestUrl(COMMUNITY_PLUGINS_URL);
+async function getPluginManifest(repo, version) {
+  const response = await 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;
+}
 export {
-  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/esm/obsidian/components/component-ex.d.mts

@@ -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.
      *