@mnaoumov/obsidian-lib 10.4.1 → 10.5.1

package/dist/lib/cjs/command-handlers/open-bug-report-command-handler.cjs

@@ -0,0 +1,139 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var open_bug_report_command_handler_exports = {};
+__export(open_bug_report_command_handler_exports, {
+  OpenBugReportCommandHandler: () => OpenBugReportCommandHandler
+});
+module.exports = __toCommonJS(open_bug_report_command_handler_exports);
+var import_bug_report = require('../bug-report.cjs');
+var import_global_command_handler = require('./global-command-handler.cjs');
+class OpenBugReportCommandHandler extends import_global_command_handler.GlobalCommandHandler {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The plugin's GitHub repository, as `owner/name`.
+   */
+  gitHubRepo;
+  /**
+   * The id of the reporting plugin.
+   */
+  pluginId;
+  /**
+   * Constructs a new instance.
+   *
+   * @param params - Constructor parameters.
+   */
+  constructor(params) {
+    super({
+      icon: "bug",
+      id: "report-bug",
+      name: "Report a bug"
+    });
+    this.app = params.app;
+    this.pluginId = params.pluginId;
+    this.gitHubRepo = params.gitHubRepo;
+  }
+  /**
+   * Executes the command, opening the prefilled issue form in the browser.
+   */
+  async execute() {
+    const url = await (0, import_bug_report.getBugReportIssueFormUrl)({
+      app: this.app,
+      gitHubRepo: this.gitHubRepo,
+      pluginId: this.pluginId
+    });
+    window.open(url, "_blank");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenBugReportCommandHandler
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/command-handlers/open-bug-report-command-handler.d.cts

@@ -0,0 +1,53 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Handles the "Report a bug" command.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import { GlobalCommandHandler } from './global-command-handler.cjs';
+/**
+ * Constructor parameters for {@link OpenBugReportCommandHandler}.
+ */
+export interface OpenBugReportCommandHandlerConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The plugin's GitHub repository, as `owner/name`.
+     */
+    readonly gitHubRepo: string;
+    /**
+     * The id of the reporting plugin.
+     */
+    readonly pluginId: string;
+}
+/**
+ * A command handler that opens the plugin's bug-report issue form on GitHub, prefilled with the
+ * environment. See {@link getBugReportIssueFormUrl} for the field ids the form must use.
+ */
+export declare class OpenBugReportCommandHandler extends GlobalCommandHandler {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The plugin's GitHub repository, as `owner/name`.
+     */
+    protected readonly gitHubRepo: string;
+    /**
+     * The id of the reporting plugin.
+     */
+    protected readonly pluginId: string;
+    /**
+     * Constructs a new instance.
+     *
+     * @param params - Constructor parameters.
+     */
+    constructor(params: OpenBugReportCommandHandlerConstructorParams);
+    /**
+     * Executes the command, opening the prefilled issue form in the browser.
+     */
+    execute(): Promise<void>;
+}

package/dist/lib/cjs/command-handlers/open-settings-command-handler.cjs

@@ -90,6 +90,7 @@ __export(open_settings_command_handler_exports, {
   OpenSettingsCommandHandler: () => OpenSettingsCommandHandler
 });
 module.exports = __toCommonJS(open_settings_command_handler_exports);
+var import_settings_modal = require('../settings-modal.cjs');
 var import_global_command_handler = require('./global-command-handler.cjs');
 class OpenSettingsCommandHandler extends import_global_command_handler.GlobalCommandHandler {
   /**
@@ -118,12 +119,14 @@ class OpenSettingsCommandHandler extends import_global_command_handler.GlobalCom
    * Executes the command.
    */
   execute() {
-    this.app.setting.open();
-    this.app.setting.openTab(this.settingTab);
+    (0, import_settings_modal.openSettingTab)({
+      app: this.app,
+      tabId: this.settingTab.id
+    });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   OpenSettingsCommandHandler
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -115,6 +115,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var community_plugins_exports = {};
 __export(community_plugins_exports, {
   ConfigureCommunityPluginResult: () => ConfigureCommunityPluginResult,
+  PluginEnableRefusedError: () => PluginEnableRefusedError,
   UpdateCommunityPluginResult: () => UpdateCommunityPluginResult,
   configureCommunityPlugin: () => configureCommunityPlugin,
   disableCommunityPlugin: () => disableCommunityPlugin,
@@ -147,6 +148,19 @@ var UpdateCommunityPluginResult = /* @__PURE__ */ ((UpdateCommunityPluginResult2
   UpdateCommunityPluginResult2["Updated"] = "updated";
   return UpdateCommunityPluginResult2;
 })(UpdateCommunityPluginResult || {});
+class PluginEnableRefusedError extends Error {
+  /**
+   * Creates a {@link PluginEnableRefusedError}.
+   *
+   * @param pluginId - The id of the plugin Obsidian refused to enable.
+   */
+  constructor(pluginId) {
+    super(`Obsidian refused to enable the plugin "${pluginId}".`);
+    this.pluginId = pluginId;
+    this.name = "PluginEnableRefusedError";
+  }
+  pluginId;
+}
 async function configureCommunityPlugin(params) {
   const { app, settings } = params;
   const pluginId = await resolveCommunityPluginId(params);
@@ -189,7 +203,9 @@ async function enableCommunityPlugin(params) {
   if (app.plugins.enabledPlugins.has(pluginId)) {
     return;
   }
-  await app.plugins.enablePluginAndSave(pluginId);
+  if (!await app.plugins.enablePluginAndSave(pluginId)) {
+    throw new PluginEnableRefusedError(pluginId);
+  }
 }
 async function getCommunityPluginRepo(pluginId) {
   const entries = await getCommunityPluginEntries();
@@ -329,6 +345,7 @@ async function resolveCommunityPluginId(reference) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConfigureCommunityPluginResult,
+  PluginEnableRefusedError,
   UpdateCommunityPluginResult,
   configureCommunityPlugin,
   disableCommunityPlugin,
@@ -343,4 +360,4 @@ async function resolveCommunityPluginId(reference) {
   uninstallCommunityPlugin,
   updateCommunityPlugin
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/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 — 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/update/uninstall/enable/disable an arbitrary community plugin — selected\n * by either its `id` or its display `name` — 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 { compare as compareVersions } from 'compare-versions';\nimport { requestUrl } from 'obsidian';\n\nimport { getObsidianLibState } from './obsidian-lib-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 configureCommunityPlugin}. Selects the plugin by either `pluginId` or\n * `pluginName`.\n */\nexport type ConfigureCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginSettings;\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 installConfigureEnableCommunityPlugin}. Selects the plugin by either `pluginId`\n * or `pluginName`; `settings` is optional (omit for a plugin that needs no configuration).\n */\nexport type InstallConfigureEnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & Partial<CommunityPluginSettings>;\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 * Parameters for {@link updateCommunityPlugin}. Selects the plugin by either `pluginId` or `pluginName`.\n */\nexport type UpdateCommunityPluginParams = 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 settings to merge into a community plugin's `data.json`.\n */\ninterface CommunityPluginSettings {\n  /**\n   * The settings object shallow-merged over the plugin's existing `data.json` (the file is created if\n   * absent).\n   */\n  readonly settings: object;\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 one method {@link configureCommunityPlugin} needs from a plugin's settings component to configure\n * it live. Declared structurally rather than importing `PluginSettingsComponent`, so a plugin built on\n * any version of it -- or on its own equivalent -- is configurable without a shared nominal type.\n */\ninterface EditableSettingsComponent {\n  readonly editAndSave: (settingsEditor: (settings: object) => void) => Promise<void>;\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';\nconst DATA_JSON_INDENT = 2;\n\n/**\n * The result of {@link configureCommunityPlugin}.\n */\nexport enum ConfigureCommunityPluginResult {\n  /**\n   * The settings were applied through the running plugin's own settings component, which both updated\n   * them in memory and persisted them. The plugin is already using them, so it must NOT be reloaded.\n   */\n  AppliedLive = 'appliedLive',\n\n  /**\n   * The settings were already present in the plugin's `data.json`, so nothing was written.\n   */\n  Skipped = 'skipped',\n\n  /**\n   * The settings were merged into the plugin's `data.json`, which was written.\n   */\n  Success = 'success'\n}\n\n/**\n * The result of {@link updateCommunityPlugin}.\n */\nexport enum UpdateCommunityPluginResult {\n  /**\n   * The installed copy is already at (or past) the latest release, so nothing was downloaded.\n   */\n  AlreadyUpToDate = 'alreadyUpToDate',\n\n  /**\n   * The latest release was installed over the old copy, which Obsidian reloaded if it was running.\n   */\n  Updated = 'updated'\n}\n\n/**\n * Configures a community plugin, preferring the running plugin's own settings component over its\n * `data.json`.\n *\n * When the plugin is loaded AND exposes a `pluginSettingsComponent` with an `editAndSave` method, the\n * settings are shallow-merged through it: they take effect immediately and are persisted, so the plugin\n * needs no reload and {@link ConfigureCommunityPluginResult.AppliedLive} is returned. This is what lets a\n * plugin's own script reconfigure it without the disable/enable cycle that would tear down the very code\n * doing the reconfiguring. Note that this path runs the plugin's setting validators, so an invalid value\n * is replaced by its default rather than written through verbatim.\n *\n * Otherwise the settings are written into the plugin's `data.json`, shallow-merged over any existing\n * settings (creating the file if absent). Writing settings BEFORE the plugin is enabled makes it load\n * already configured, with no reload. A no-op write is skipped: when the merge changes nothing, the file\n * is left untouched and {@link ConfigureCommunityPluginResult.Skipped} is returned, so a caller can avoid\n * reloading an already-correctly-configured plugin.\n *\n * @param params - The {@link ConfigureCommunityPluginParams}.\n * @returns A {@link Promise} that resolves to {@link ConfigureCommunityPluginResult.AppliedLive} if the\n * running plugin applied them itself (no reload needed), {@link ConfigureCommunityPluginResult.Success} if\n * the `data.json` content changed (and was written), or {@link ConfigureCommunityPluginResult.Skipped} if\n * the settings were already present (nothing written).\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function configureCommunityPlugin(params: ConfigureCommunityPluginParams): Promise<ConfigureCommunityPluginResult> {\n  const { app, settings } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n\n  const settingsComponent = getSettingsComponent(app.plugins.plugins[pluginId]);\n  if (checkHasEditAndSave(settingsComponent)) {\n    await settingsComponent.editAndSave((pluginSettings) => {\n      Object.assign(pluginSettings, settings);\n    });\n    return ConfigureCommunityPluginResult.AppliedLive;\n  }\n\n  const dataPath = `${app.vault.configDir}/plugins/${pluginId}/data.json`;\n\n  let data: object = {};\n  if (await app.vault.adapter.exists(dataPath)) {\n    const parsed: unknown = JSON.parse(await app.vault.adapter.read(dataPath));\n    if (parsed !== null && typeof parsed === 'object') {\n      data = parsed;\n    }\n  }\n\n  const serializedBefore = JSON.stringify(data);\n  Object.assign(data, settings);\n  if (JSON.stringify(data) === serializedBefore) {\n    return ConfigureCommunityPluginResult.Skipped;\n  }\n\n  const serialized = String(JSON.stringify(data, null, DATA_JSON_INDENT));\n  await app.vault.adapter.write(dataPath, `${serialized}\\n`);\n  return ConfigureCommunityPluginResult.Success;\n}\n\n/**\n * Disables a community plugin (persisting the change) if it is currently enabled. Idempotent — 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 — 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 — 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 (Object.hasOwn(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 * Installs a community plugin, writes its settings, THEN enables it — in that order — so the plugin\n * loads already configured (a plugin enabled before it is configured runs its `onload` with default\n * settings and does nothing useful). If the plugin is already enabled and the settings changed, it is\n * disabled and re-enabled so the new settings take effect. `settings` is optional: omit it for a plugin\n * that needs no configuration. Composes {@link installCommunityPlugin}, {@link configureCommunityPlugin},\n * {@link enableCommunityPlugin} and {@link disableCommunityPlugin}.\n *\n * @param params - The {@link InstallConfigureEnableCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is installed, configured and enabled.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function installConfigureEnableCommunityPlugin(params: InstallConfigureEnableCommunityPluginParams): Promise<void> {\n  const { app, settings } = params;\n  await installCommunityPlugin(params);\n  const didSettingsChange = settings ? await configureCommunityPlugin({ ...params, settings }) === ConfigureCommunityPluginResult.Success : false;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (!app.plugins.enabledPlugins.has(pluginId)) {\n    await enableCommunityPlugin(params);\n  } else if (didSettingsChange) {\n    await disableCommunityPlugin(params);\n    await enableCommunityPlugin(params);\n  }\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 — 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 (!Object.hasOwn(app.plugins.manifests, pluginId)) {\n    return;\n  }\n  await app.plugins.uninstallPlugin(pluginId);\n}\n\n/**\n * Updates an installed community plugin to its latest release, the way the community plugin browser's own\n * `Update` button does.\n *\n * Obsidian's `installPlugin` writes the release's files over the installed copy and, when the plugin is\n * running, disables and re-enables it so the new code loads — read from the shipped bundle (`1.14.4`), not\n * assumed. It reports its own failures (a failed download, a manifest whose id does not match) as a notice\n * and RETURNS rather than throwing, so the installed manifest is re-read afterwards and a version that did\n * not move to the release is thrown as a failure.\n *\n * @param params - The {@link UpdateCommunityPluginParams}.\n * @returns A {@link Promise} resolving to {@link UpdateCommunityPluginResult.Updated} once the latest release\n * is installed, or {@link UpdateCommunityPluginResult.AlreadyUpToDate} when the installed copy is not older\n * than it.\n * @throws If the plugin is not installed, is not listed in Obsidian's community plugins registry, or the\n * install did not leave the latest release in place.\n */\nexport async function updateCommunityPlugin(params: UpdateCommunityPluginParams): Promise<UpdateCommunityPluginResult> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  const installedManifest = app.plugins.manifests[pluginId];\n  if (!installedManifest) {\n    throw new Error(`Plugin '${pluginId}' is not installed, so it cannot be updated.`);\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  if (isAtLeastVersion(installedManifest.version, version)) {\n    return UpdateCommunityPluginResult.AlreadyUpToDate;\n  }\n\n  const manifest = await getPluginManifest(repo, version);\n  await app.plugins.installPlugin(repo, version, manifest);\n\n  const updatedVersion = app.plugins.manifests[pluginId]?.version;\n  if (updatedVersion !== manifest.version) {\n    throw new Error(\n      `Updating plugin '${pluginId}' to ${manifest.version} left version ${updatedVersion ?? '(none)'} installed. Obsidian reports the cause as a notice.`\n    );\n  }\n\n  return UpdateCommunityPluginResult.Updated;\n}\n\n// Whether a plugin's `pluginSettingsComponent` can configure itself in place. Structural rather than an\n// `instanceof`: the plugin was loaded from its own bundle, so even a plugin built on this very library\n// carries its own copy of the class and would fail an identity check.\nfunction checkHasEditAndSave(settingsComponent: unknown): settingsComponent is EditableSettingsComponent {\n  return typeof settingsComponent === 'object'\n    && settingsComponent !== null\n    && 'editAndSave' in settingsComponent\n    && typeof settingsComponent.editAndSave === 'function';\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 = getObsidianLibState<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\n// Reads a loaded plugin's `pluginSettingsComponent`, or `null` when it has none. Takes `unknown` because\n// A plugin is under no obligation to expose one, so there is no type to narrow from.\nfunction getSettingsComponent(plugin: unknown): unknown {\n  return typeof plugin !== 'object' || plugin === null || !('pluginSettingsComponent' in plugin) ? null : plugin.pluginSettingsComponent;\n}\n\n// A version that cannot be parsed reads as older, so an update is attempted rather than skipped: the install's\n// own version check afterwards still catches a release that does not move it.\nfunction isAtLeastVersion(installedVersion: string, latestVersion: string): boolean {\n  try {\n    return compareVersions(installedVersion, latestVersion, '>=');\n  } catch {\n    return false;\n  }\n}\n\nasync function resolveCommunityPluginId(reference: CommunityPluginRef): Promise<string> {\n  if ('pluginId' in reference) {\n    return reference.pluginId;\n  }\n\n  const entries = await getCommunityPluginEntries();\n  const entry = entries.find((candidate) => candidate.name === reference.pluginName);\n  if (!entry) {\n    throw new Error(`Plugin named '${reference.pluginName}' was not found in the Obsidian community plugins registry.`);\n  }\n  return entry.id;\n}\n"],"mappings":"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","names":["ConfigureCommunityPluginResult","UpdateCommunityPluginResult","compareVersions"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/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 — 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/update/uninstall/enable/disable an arbitrary community plugin — selected\n * by either its `id` or its display `name` — 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 { compare as compareVersions } from 'compare-versions';\nimport { requestUrl } from 'obsidian';\n\nimport { getObsidianLibState } from './obsidian-lib-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 configureCommunityPlugin}. Selects the plugin by either `pluginId` or\n * `pluginName`.\n */\nexport type ConfigureCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginSettings;\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 installConfigureEnableCommunityPlugin}. Selects the plugin by either `pluginId`\n * or `pluginName`; `settings` is optional (omit for a plugin that needs no configuration).\n */\nexport type InstallConfigureEnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & Partial<CommunityPluginSettings>;\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 * Parameters for {@link updateCommunityPlugin}. Selects the plugin by either `pluginId` or `pluginName`.\n */\nexport type UpdateCommunityPluginParams = 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 settings to merge into a community plugin's `data.json`.\n */\ninterface CommunityPluginSettings {\n  /**\n   * The settings object shallow-merged over the plugin's existing `data.json` (the file is created if\n   * absent).\n   */\n  readonly settings: object;\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 one method {@link configureCommunityPlugin} needs from a plugin's settings component to configure\n * it live. Declared structurally rather than importing `PluginSettingsComponent`, so a plugin built on\n * any version of it -- or on its own equivalent -- is configurable without a shared nominal type.\n */\ninterface EditableSettingsComponent {\n  readonly editAndSave: (settingsEditor: (settings: object) => void) => Promise<void>;\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';\nconst DATA_JSON_INDENT = 2;\n\n/**\n * The result of {@link configureCommunityPlugin}.\n */\nexport enum ConfigureCommunityPluginResult {\n  /**\n   * The settings were applied through the running plugin's own settings component, which both updated\n   * them in memory and persisted them. The plugin is already using them, so it must NOT be reloaded.\n   */\n  AppliedLive = 'appliedLive',\n\n  /**\n   * The settings were already present in the plugin's `data.json`, so nothing was written.\n   */\n  Skipped = 'skipped',\n\n  /**\n   * The settings were merged into the plugin's `data.json`, which was written.\n   */\n  Success = 'success'\n}\n\n/**\n * The result of {@link updateCommunityPlugin}.\n */\nexport enum UpdateCommunityPluginResult {\n  /**\n   * The installed copy is already at (or past) the latest release, so nothing was downloaded.\n   */\n  AlreadyUpToDate = 'alreadyUpToDate',\n\n  /**\n   * The latest release was installed over the old copy, which Obsidian reloaded if it was running.\n   */\n  Updated = 'updated'\n}\n\n/**\n * Thrown when Obsidian refuses to enable a plugin: its `enablePlugin` / `enablePluginAndSave` resolved\n * `false`, because the plugin is unknown, deprecated, desktop-only on mobile, or threw while loading.\n */\nexport class PluginEnableRefusedError extends Error {\n  /**\n   * Creates a {@link PluginEnableRefusedError}.\n   *\n   * @param pluginId - The id of the plugin Obsidian refused to enable.\n   */\n  public constructor(public readonly pluginId: string) {\n    super(`Obsidian refused to enable the plugin \"${pluginId}\".`);\n    this.name = 'PluginEnableRefusedError';\n  }\n}\n\n/**\n * Configures a community plugin, preferring the running plugin's own settings component over its\n * `data.json`.\n *\n * When the plugin is loaded AND exposes a `pluginSettingsComponent` with an `editAndSave` method, the\n * settings are shallow-merged through it: they take effect immediately and are persisted, so the plugin\n * needs no reload and {@link ConfigureCommunityPluginResult.AppliedLive} is returned. This is what lets a\n * plugin's own script reconfigure it without the disable/enable cycle that would tear down the very code\n * doing the reconfiguring. Note that this path runs the plugin's setting validators, so an invalid value\n * is replaced by its default rather than written through verbatim.\n *\n * Otherwise the settings are written into the plugin's `data.json`, shallow-merged over any existing\n * settings (creating the file if absent). Writing settings BEFORE the plugin is enabled makes it load\n * already configured, with no reload. A no-op write is skipped: when the merge changes nothing, the file\n * is left untouched and {@link ConfigureCommunityPluginResult.Skipped} is returned, so a caller can avoid\n * reloading an already-correctly-configured plugin.\n *\n * @param params - The {@link ConfigureCommunityPluginParams}.\n * @returns A {@link Promise} that resolves to {@link ConfigureCommunityPluginResult.AppliedLive} if the\n * running plugin applied them itself (no reload needed), {@link ConfigureCommunityPluginResult.Success} if\n * the `data.json` content changed (and was written), or {@link ConfigureCommunityPluginResult.Skipped} if\n * the settings were already present (nothing written).\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function configureCommunityPlugin(params: ConfigureCommunityPluginParams): Promise<ConfigureCommunityPluginResult> {\n  const { app, settings } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n\n  const settingsComponent = getSettingsComponent(app.plugins.plugins[pluginId]);\n  if (checkHasEditAndSave(settingsComponent)) {\n    await settingsComponent.editAndSave((pluginSettings) => {\n      Object.assign(pluginSettings, settings);\n    });\n    return ConfigureCommunityPluginResult.AppliedLive;\n  }\n\n  const dataPath = `${app.vault.configDir}/plugins/${pluginId}/data.json`;\n\n  let data: object = {};\n  if (await app.vault.adapter.exists(dataPath)) {\n    const parsed: unknown = JSON.parse(await app.vault.adapter.read(dataPath));\n    if (parsed !== null && typeof parsed === 'object') {\n      data = parsed;\n    }\n  }\n\n  const serializedBefore = JSON.stringify(data);\n  Object.assign(data, settings);\n  if (JSON.stringify(data) === serializedBefore) {\n    return ConfigureCommunityPluginResult.Skipped;\n  }\n\n  const serialized = String(JSON.stringify(data, null, DATA_JSON_INDENT));\n  await app.vault.adapter.write(dataPath, `${serialized}\\n`);\n  return ConfigureCommunityPluginResult.Success;\n}\n\n/**\n * Disables a community plugin (persisting the change) if it is currently enabled. Idempotent — 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 — 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 * @throws {@link PluginEnableRefusedError} If Obsidian refused to enable the plugin; nothing is saved then.\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  if (!await app.plugins.enablePluginAndSave(pluginId)) {\n    throw new PluginEnableRefusedError(pluginId);\n  }\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 — 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 (Object.hasOwn(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 * Installs a community plugin, writes its settings, THEN enables it — in that order — so the plugin\n * loads already configured (a plugin enabled before it is configured runs its `onload` with default\n * settings and does nothing useful). If the plugin is already enabled and the settings changed, it is\n * disabled and re-enabled so the new settings take effect. `settings` is optional: omit it for a plugin\n * that needs no configuration. Composes {@link installCommunityPlugin}, {@link configureCommunityPlugin},\n * {@link enableCommunityPlugin} and {@link disableCommunityPlugin}.\n *\n * @param params - The {@link InstallConfigureEnableCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is installed, configured and enabled.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function installConfigureEnableCommunityPlugin(params: InstallConfigureEnableCommunityPluginParams): Promise<void> {\n  const { app, settings } = params;\n  await installCommunityPlugin(params);\n  const didSettingsChange = settings ? await configureCommunityPlugin({ ...params, settings }) === ConfigureCommunityPluginResult.Success : false;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (!app.plugins.enabledPlugins.has(pluginId)) {\n    await enableCommunityPlugin(params);\n  } else if (didSettingsChange) {\n    await disableCommunityPlugin(params);\n    await enableCommunityPlugin(params);\n  }\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 — 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 (!Object.hasOwn(app.plugins.manifests, pluginId)) {\n    return;\n  }\n  await app.plugins.uninstallPlugin(pluginId);\n}\n\n/**\n * Updates an installed community plugin to its latest release, the way the community plugin browser's own\n * `Update` button does.\n *\n * Obsidian's `installPlugin` writes the release's files over the installed copy and, when the plugin is\n * running, disables and re-enables it so the new code loads — read from the shipped bundle (`1.14.4`), not\n * assumed. It reports its own failures (a failed download, a manifest whose id does not match) as a notice\n * and RETURNS rather than throwing, so the installed manifest is re-read afterwards and a version that did\n * not move to the release is thrown as a failure.\n *\n * @param params - The {@link UpdateCommunityPluginParams}.\n * @returns A {@link Promise} resolving to {@link UpdateCommunityPluginResult.Updated} once the latest release\n * is installed, or {@link UpdateCommunityPluginResult.AlreadyUpToDate} when the installed copy is not older\n * than it.\n * @throws If the plugin is not installed, is not listed in Obsidian's community plugins registry, or the\n * install did not leave the latest release in place.\n */\nexport async function updateCommunityPlugin(params: UpdateCommunityPluginParams): Promise<UpdateCommunityPluginResult> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  const installedManifest = app.plugins.manifests[pluginId];\n  if (!installedManifest) {\n    throw new Error(`Plugin '${pluginId}' is not installed, so it cannot be updated.`);\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  if (isAtLeastVersion(installedManifest.version, version)) {\n    return UpdateCommunityPluginResult.AlreadyUpToDate;\n  }\n\n  const manifest = await getPluginManifest(repo, version);\n  await app.plugins.installPlugin(repo, version, manifest);\n\n  const updatedVersion = app.plugins.manifests[pluginId]?.version;\n  if (updatedVersion !== manifest.version) {\n    throw new Error(\n      `Updating plugin '${pluginId}' to ${manifest.version} left version ${updatedVersion ?? '(none)'} installed. Obsidian reports the cause as a notice.`\n    );\n  }\n\n  return UpdateCommunityPluginResult.Updated;\n}\n\n// Whether a plugin's `pluginSettingsComponent` can configure itself in place. Structural rather than an\n// `instanceof`: the plugin was loaded from its own bundle, so even a plugin built on this very library\n// carries its own copy of the class and would fail an identity check.\nfunction checkHasEditAndSave(settingsComponent: unknown): settingsComponent is EditableSettingsComponent {\n  return typeof settingsComponent === 'object'\n    && settingsComponent !== null\n    && 'editAndSave' in settingsComponent\n    && typeof settingsComponent.editAndSave === 'function';\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 = getObsidianLibState<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\n// Reads a loaded plugin's `pluginSettingsComponent`, or `null` when it has none. Takes `unknown` because\n// A plugin is under no obligation to expose one, so there is no type to narrow from.\nfunction getSettingsComponent(plugin: unknown): unknown {\n  return typeof plugin !== 'object' || plugin === null || !('pluginSettingsComponent' in plugin) ? null : plugin.pluginSettingsComponent;\n}\n\n// A version that cannot be parsed reads as older, so an update is attempted rather than skipped: the install's\n// own version check afterwards still catches a release that does not move it.\nfunction isAtLeastVersion(installedVersion: string, latestVersion: string): boolean {\n  try {\n    return compareVersions(installedVersion, latestVersion, '>=');\n  } catch {\n    return false;\n  }\n}\n\nasync function resolveCommunityPluginId(reference: CommunityPluginRef): Promise<string> {\n  if ('pluginId' in reference) {\n    return reference.pluginId;\n  }\n\n  const entries = await getCommunityPluginEntries();\n  const entry = entries.find((candidate) => candidate.name === reference.pluginName);\n  if (!entry) {\n    throw new Error(`Plugin named '${reference.pluginName}' was not found in the Obsidian community plugins registry.`);\n  }\n  return entry.id;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBA,8BAA2C;AAC3C,sBAA2B;AAE3B,gCAAoC;AA0LpC,MAAM,8BAA8B;AACpC,MAAM,wBAAwB;AAC9B,MAAM,mBAAmB;AAKlB,IAAK,iCAAL,kBAAKA,oCAAL;AAKL,EAAAA,gCAAA,iBAAc;AAKd,EAAAA,gCAAA,aAAU;AAKV,EAAAA,gCAAA,aAAU;AAfA,SAAAA;AAAA,GAAA;AAqBL,IAAK,8BAAL,kBAAKC,iCAAL;AAIL,EAAAA,6BAAA,qBAAkB;AAKlB,EAAAA,6BAAA,aAAU;AATA,SAAAA;AAAA,GAAA;AAgBL,MAAM,iCAAiC,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM3C,YAA4B,UAAkB;AACnD,UAAM,0CAA0C,QAAQ,IAAI;AAD3B;AAEjC,SAAK,OAAO;AAAA,EACd;AAAA,EAHmC;AAIrC;AA0BA,eAAsB,yBAAyB,QAAiF;AAC9H,QAAM,EAAE,KAAK,SAAS,IAAI;AAC1B,QAAM,WAAW,MAAM,yBAAyB,MAAM;AAEtD,QAAM,oBAAoB,qBAAqB,IAAI,QAAQ,QAAQ,QAAQ,CAAC;AAC5E,MAAI,oBAAoB,iBAAiB,GAAG;AAC1C,UAAM,kBAAkB,YAAY,CAAC,mBAAmB;AACtD,aAAO,OAAO,gBAAgB,QAAQ;AAAA,IACxC,CAAC;AACD,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,GAAG,IAAI,MAAM,SAAS,YAAY,QAAQ;AAE3D,MAAI,OAAe,CAAC;AACpB,MAAI,MAAM,IAAI,MAAM,QAAQ,OAAO,QAAQ,GAAG;AAC5C,UAAM,SAAkB,KAAK,MAAM,MAAM,IAAI,MAAM,QAAQ,KAAK,QAAQ,CAAC;AACzE,QAAI,WAAW,QAAQ,OAAO,WAAW,UAAU;AACjD,aAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,mBAAmB,KAAK,UAAU,IAAI;AAC5C,SAAO,OAAO,MAAM,QAAQ;AAC5B,MAAI,KAAK,UAAU,IAAI,MAAM,kBAAkB;AAC7C,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,OAAO,KAAK,UAAU,MAAM,MAAM,gBAAgB,CAAC;AACtE,QAAM,IAAI,MAAM,QAAQ,MAAM,UAAU,GAAG,UAAU;AAAA,CAAI;AACzD,SAAO;AACT;AAUA,eAAsB,uBAAuB,QAAqD;AAChG,QAAM,EAAE,IAAI,IAAI;AAChB,QAAM,WAAW,MAAM,yBAAyB,MAAM;AACtD,MAAI,CAAC,IAAI,QAAQ,eAAe,IAAI,QAAQ,GAAG;AAC7C;AAAA,EACF;AACA,QAAM,IAAI,QAAQ,qBAAqB,QAAQ;AACjD;AAWA,eAAsB,sBAAsB,QAAoD;AAC9F,QAAM,EAAE,IAAI,IAAI;AAChB,QAAM,WAAW,MAAM,yBAAyB,MAAM;AACtD,MAAI,IAAI,QAAQ,eAAe,IAAI,QAAQ,GAAG;AAC5C;AAAA,EACF;AACA,MAAI,CAAC,MAAM,IAAI,QAAQ,oBAAoB,QAAQ,GAAG;AACpD,UAAM,IAAI,yBAAyB,QAAQ;AAAA,EAC7C;AACF;AAaA,eAAsB,uBAAuB,UAA0C;AACrF,QAAM,UAAU,MAAM,0BAA0B;AAChD,QAAM,QAAQ,QAAQ,KAAK,CAAC,cAAc,UAAU,OAAO,QAAQ;AACnE,SAAO,OAAO,QAAQ;AACxB;AASA,eAAsB,wBAAwB,MAA+B;AAC3E,QAAM,WAAW,UAAM,4BAAW,gCAAgC,IAAI,kBAAkB;AACxF,QAAM,UAAU,SAAS;AACzB,SAAO,QAAQ;AACjB;AAYA,eAAsB,uBAAuB,QAAqD;AAChG,QAAM,EAAE,IAAI,IAAI;AAChB,QAAM,WAAW,MAAM,yBAAyB,MAAM;AACtD,MAAI,OAAO,OAAO,IAAI,QAAQ,WAAW,QAAQ,GAAG;AAClD;AAAA,EACF;AAEA,QAAM,OAAO,MAAM,uBAAuB,QAAQ;AAClD,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,WAAW,QAAQ,6DAA6D;AAAA,EAClG;AAEA,QAAM,UAAU,MAAM,wBAAwB,IAAI;AAClD,QAAM,WAAW,MAAM,kBAAkB,MAAM,OAAO;AACtD,QAAM,IAAI,QAAQ,cAAc,MAAM,SAAS,QAAQ;AACzD;AAcA,eAAsB,sCAAsC,QAAoE;AAC9H,QAAM,EAAE,KAAK,SAAS,IAAI;AAC1B,QAAM,uBAAuB,MAAM;AACnC,QAAM,oBAAoB,WAAW,MAAM,yBAAyB,EAAE,GAAG,QAAQ,SAAS,CAAC,MAAM,0BAAyC;AAC1I,QAAM,WAAW,MAAM,yBAAyB,MAAM;AACtD,MAAI,CAAC,IAAI,QAAQ,eAAe,IAAI,QAAQ,GAAG;AAC7C,UAAM,sBAAsB,MAAM;AAAA,EACpC,WAAW,mBAAmB;AAC5B,UAAM,uBAAuB,MAAM;AACnC,UAAM,sBAAsB,MAAM;AAAA,EACpC;AACF;AAUA,eAAsB,uBAAuB,OAAuD;AAClG,QAAM,UAAU,MAAM,0BAA0B;AAChD,QAAM,kBAAkB,MAAM,YAAY;AAC1C,SAAO,QACJ;AAAA,IAAO,CAAC,UACP,MAAM,GAAG,YAAY,EAAE,SAAS,eAAe,KAC5C,MAAM,KAAK,YAAY,EAAE,SAAS,eAAe,KACjD,MAAM,OAAO,YAAY,EAAE,SAAS,eAAe,KACnD,MAAM,YAAY,YAAY,EAAE,SAAS,eAAe;AAAA,EAC7D,EACC,IAAI,CAAC,WAAW;AAAA,IACf,IAAI,MAAM;AAAA,IACV,MAAM,MAAM;AAAA,EACd,EAAE;AACN;AAUA,eAAsB,4BAA4B,QAA0D;AAC1G,MAAI,OAAO,WAAW;AACpB,UAAM,sBAAsB,MAAM;AAAA,EACpC,OAAO;AACL,UAAM,uBAAuB,MAAM;AAAA,EACrC;AACF;AAUA,eAAsB,6BAA6B,QAA2D;AAC5G,MAAI,OAAO,aAAa;AACtB,UAAM,uBAAuB,MAAM;AAAA,EACrC,OAAO;AACL,UAAM,yBAAyB,MAAM;AAAA,EACvC;AACF;AAUA,eAAsB,yBAAyB,QAAuD;AACpG,QAAM,EAAE,IAAI,IAAI;AAChB,QAAM,WAAW,MAAM,yBAAyB,MAAM;AACtD,MAAI,CAAC,OAAO,OAAO,IAAI,QAAQ,WAAW,QAAQ,GAAG;AACnD;AAAA,EACF;AACA,QAAM,IAAI,QAAQ,gBAAgB,QAAQ;AAC5C;AAmBA,eAAsB,sBAAsB,QAA2E;AACrH,QAAM,EAAE,IAAI,IAAI;AAChB,QAAM,WAAW,MAAM,yBAAyB,MAAM;AACtD,QAAM,oBAAoB,IAAI,QAAQ,UAAU,QAAQ;AACxD,MAAI,CAAC,mBAAmB;AACtB,UAAM,IAAI,MAAM,WAAW,QAAQ,8CAA8C;AAAA,EACnF;AAEA,QAAM,OAAO,MAAM,uBAAuB,QAAQ;AAClD,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,WAAW,QAAQ,6DAA6D;AAAA,EAClG;AAEA,QAAM,UAAU,MAAM,wBAAwB,IAAI;AAClD,MAAI,iBAAiB,kBAAkB,SAAS,OAAO,GAAG;AACxD,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,MAAM,kBAAkB,MAAM,OAAO;AACtD,QAAM,IAAI,QAAQ,cAAc,MAAM,SAAS,QAAQ;AAEvD,QAAM,iBAAiB,IAAI,QAAQ,UAAU,QAAQ,GAAG;AACxD,MAAI,mBAAmB,SAAS,SAAS;AACvC,UAAM,IAAI;AAAA,MACR,oBAAoB,QAAQ,QAAQ,SAAS,OAAO,iBAAiB,kBAAkB,QAAQ;AAAA,IACjG;AAAA,EACF;AAEA,SAAO;AACT;AAKA,SAAS,oBAAoB,mBAA4E;AACvG,SAAO,OAAO,sBAAsB,YAC/B,sBAAsB,QACtB,iBAAiB,qBACjB,OAAO,kBAAkB,gBAAgB;AAChD;AAEA,eAAe,8BAA+D;AAC5E,QAAM,WAAW,UAAM,4BAAW,qBAAqB;AACvD,SAAO,SAAS;AAClB;AAEA,eAAe,4BAA6D;AAC1E,QAAM,YAAQ,+CAA4D,6BAA6B,IAAI;AAC3G,QAAM,UAAU,4BAA4B;AAE5C,MAAI;AACF,WAAO,MAAM,MAAM;AAAA,EACrB,SAAS,OAAO;AACd,UAAM,QAAQ;AACd,UAAM;AAAA,EACR;AACF;AAEA,eAAe,kBAAkB,MAAc,SAA0C;AACvF,QAAM,WAAW,UAAM,4BAAW,sBAAsB,IAAI,sBAAsB,OAAO,gBAAgB;AACzG,SAAO,SAAS;AAClB;AAIA,SAAS,qBAAqB,QAA0B;AACtD,SAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,EAAE,6BAA6B,UAAU,OAAO,OAAO;AACjH;AAIA,SAAS,iBAAiB,kBAA0B,eAAgC;AAClF,MAAI;AACF,eAAO,wBAAAC,SAAgB,kBAAkB,eAAe,IAAI;AAAA,EAC9D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,eAAe,yBAAyB,WAAgD;AACtF,MAAI,cAAc,WAAW;AAC3B,WAAO,UAAU;AAAA,EACnB;AAEA,QAAM,UAAU,MAAM,0BAA0B;AAChD,QAAM,QAAQ,QAAQ,KAAK,CAAC,cAAc,UAAU,SAAS,UAAU,UAAU;AACjF,MAAI,CAAC,OAAO;AACV,UAAM,IAAI,MAAM,iBAAiB,UAAU,UAAU,6DAA6D;AAAA,EACpH;AACA,SAAO,MAAM;AACf;","names":["ConfigureCommunityPluginResult","UpdateCommunityPluginResult","compareVersions"]}

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

@@ -161,6 +161,19 @@ export declare enum UpdateCommunityPluginResult {
      */
     Updated = "updated"
 }
+/**
+ * Thrown when Obsidian refuses to enable a plugin: its `enablePlugin` / `enablePluginAndSave` resolved
+ * `false`, because the plugin is unknown, deprecated, desktop-only on mobile, or threw while loading.
+ */
+export declare class PluginEnableRefusedError extends Error {
+    readonly pluginId: string;
+    /**
+     * Creates a {@link PluginEnableRefusedError}.
+     *
+     * @param pluginId - The id of the plugin Obsidian refused to enable.
+     */
+    constructor(pluginId: string);
+}
 /**
  * Configures a community plugin, preferring the running plugin's own settings component over its
  * `data.json`.
@@ -202,6 +215,7 @@ export declare function disableCommunityPlugin(params: DisableCommunityPluginPar
  * @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.
+ * @throws {@link PluginEnableRefusedError} If Obsidian refused to enable the plugin; nothing is saved then.
  */
 export declare function enableCommunityPlugin(params: EnableCommunityPluginParams): Promise<void>;
 /**

package/dist/lib/cjs/components/bulk-operation-commit-component.cjs

@@ -204,7 +204,7 @@ class BulkOperationCommitComponent extends import_component_ex.ComponentEx {
     if (!repo) {
       return await params.operation();
     }
-    const { commitSha, operationId, result } = await repo.runBulkOperation({
+    const { commitSha, operationId, recoveredOperationId, result } = await repo.runBulkOperation({
       operation: async () => await params.operation(),
       pluginId: this.pluginId,
       settle: () => this.settle(),
@@ -213,6 +213,9 @@ class BulkOperationCommitComponent extends import_component_ex.ComponentEx {
     (0, import_debug.getObsidianLibDebugger)("BulkOperationCommitComponent")(
       commitSha === null ? `${operationId} changed nothing` : `${operationId} committed as ${commitSha}`
     );
+    if (recoveredOperationId !== null) {
+      this.pluginNoticeComponent.showNotice((0, import_i18n.t)(($) => $.obsidianLib.bulkOperation.resumedAfterRecovery, { operationId, recoveredOperationId }));
+    }
     return result;
   }
   /**
@@ -334,4 +337,4 @@ function formatCommit(commit) {
 0 && (module.exports = {
   BulkOperationCommitComponent
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/bulk-operation-commit-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains class {@link BulkOperationCommitComponent} that wraps a plugin's bulk operations in git commits, so\n * `git revert` undoes one.\n */\n\nimport type {\n  App,\n  EventRef\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  invokeAsyncSafely,\n  setTimeoutAsync\n} from '@mnaoumov/typescript-lib/async';\nimport { errorToString } from '@mnaoumov/typescript-lib/error';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport {\n  FileSystemAdapter,\n  Platform\n} from 'obsidian';\n\nimport type { BulkOperationCommit } from '../bulk-operation.ts';\nimport type { BulkOperationGitRepo } from '../desktop-bulk-operation-git.ts';\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\n\nimport { reportBulkOperationProgress } from '../bulk-operation-progress.ts';\nimport { getObsidianLibDebugger } from '../debug.ts';\nimport { waitForPendingLinkUpdates } from '../file-manager.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { ensureMetadataCacheReady } from '../metadata-cache.ts';\nimport { selectItem } from '../modals/select-item.ts';\nimport { flushQueue } from '../queue.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * Constructor parameters for {@link BulkOperationCommitComponent}.\n */\nexport interface BulkOperationCommitComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether the plugin's opt-in setting for bulk-operation commits is on. Read on every operation, so a settings\n   * change applies to the next one.\n   */\n  readonly isEnabled: () => boolean;\n\n  /**\n   * The longest the settle step waits for the vault to go quiet after an operation.\n   *\n   * @default `60_000`\n   */\n  readonly maxSettleTimeInMilliseconds?: number;\n\n  /**\n   * The id of the plugin whose operations are committed.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The notice component used to report problems.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * How long the vault must go without a change after an operation before its commit is made.\n   *\n   * @default `2000`\n   */\n  readonly quietPeriodInMilliseconds?: number;\n}\n\n/**\n * Parameters for {@link BulkOperationCommitComponent.runBulkOperation}.\n *\n * @typeParam T - The type of the operation's result.\n */\nexport interface BulkOperationCommitComponentRunBulkOperationParams<T> {\n  /**\n   * Runs the bulk operation.\n   *\n   * @returns The operation's result.\n   */\n  readonly operation: () => Promisable<T>;\n\n  /**\n   * A one-line description of the operation, used in the commit subject, such as `Collect attachments in Notes`.\n   */\n  readonly summary: string;\n}\n\nconst DEFAULT_MAX_SETTLE_TIME_IN_MILLISECONDS = 60_000;\nconst DEFAULT_QUIET_PERIOD_IN_MILLISECONDS = 2000;\nconst SHORT_SHA_LENGTH = 8;\n\n/**\n * Wraps a plugin's bulk operations in git commits, so `git revert` of one commit undoes one operation.\n *\n * @remarks\n * Opt-in through the plugin's own setting, and active only on desktop, for a vault inside a git work tree. When it\n * is not active, {@link runBulkOperation} simply runs the operation. When it is, the operation runs between a\n * `chore: before OP<n>` commit of whatever was pending and an `OP<n>: <summary>` commit of what it changed, under\n * a lease lock in the repo's git directory that the scheduled vault autocommit honors. The lock's heartbeat\n * is refreshed by the operation's progress: every `loop()` item, or an explicit `reportBulkOperationProgress()`.\n *\n * On load it recovers a lock left stale by a crash, committing the leftovers as `OP<n> interrupted`.\n *\n * Pair it with `UndoBulkOperationCommandHandler`, which lists the plugin's operations and reverts one.\n *\n * @example\n * ```ts\n * this.bulkOperationCommitComponent = this.addChild(new BulkOperationCommitComponent({\n *   app: this.app,\n *   isEnabled: () => this.settings.shouldCommitBulkOperations,\n *   pluginId: this.manifest.id,\n *   pluginNoticeComponent: this.pluginNoticeComponent\n * }));\n *\n * await this.bulkOperationCommitComponent.runBulkOperation({\n *   operation: () => collectAttachmentsInFolder(folder),\n *   summary: `Collect attachments in ${folder.path}`\n * });\n * ```\n */\nexport class BulkOperationCommitComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * Whether the plugin's opt-in setting is on.\n   */\n  protected readonly isEnabled: () => boolean;\n\n  /**\n   * The id of the plugin whose operations are committed.\n   */\n  protected readonly pluginId: string;\n\n  /**\n   * The notice component used to report problems.\n   */\n  protected readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  private readonly maxSettleTimeInMilliseconds: number;\n  private readonly quietPeriodInMilliseconds: number;\n  private repoPromise: null | Promise<BulkOperationGitRepo | null> = null;\n\n  /**\n   * Creates a new instance.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: BulkOperationCommitComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.isEnabled = params.isEnabled;\n    this.pluginId = params.pluginId;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.maxSettleTimeInMilliseconds = params.maxSettleTimeInMilliseconds ?? DEFAULT_MAX_SETTLE_TIME_IN_MILLISECONDS;\n    this.quietPeriodInMilliseconds = params.quietPeriodInMilliseconds ?? DEFAULT_QUIET_PERIOD_IN_MILLISECONDS;\n  }\n\n  /**\n   * Checks whether bulk operations are currently committed: the setting is on, the app is desktop and the vault is\n   * inside a git work tree.\n   *\n   * @returns Whether bulk operations are committed.\n   */\n  public async checkActive(): Promise<boolean> {\n    return await this.getRepo() !== null;\n  }\n\n  /**\n   * Recovers a stale lock left by a crashed operation once the component loads.\n   */\n  public override onload(): void {\n    super.onload();\n    invokeAsyncSafely(() => this.recoverStaleLock());\n  }\n\n  /**\n   * Runs a bulk operation, wrapped in git commits when bulk-operation commits are active.\n   *\n   * @typeParam T - The type of the operation's result.\n   * @param params - The parameters.\n   * @returns The operation's result.\n   */\n  public async runBulkOperation<T>(params: BulkOperationCommitComponentRunBulkOperationParams<T>): Promise<T> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      return await params.operation();\n    }\n\n    const { commitSha, operationId, result } = await repo.runBulkOperation({\n      operation: async () => await params.operation(),\n      pluginId: this.pluginId,\n      settle: () => this.settle(),\n      summary: params.summary\n    });\n    getObsidianLibDebugger('BulkOperationCommitComponent')(\n      commitSha === null ? `${operationId} changed nothing` : `${operationId} committed as ${commitSha}`\n    );\n    return result;\n  }\n\n  /**\n   * Lets the user pick one of the plugin's bulk operations and reverts its commit.\n   *\n   * A conflict is reported and left for the user to resolve; the revert is never aborted.\n   *\n   * @param operationId - The operation to undo, such as `OP12`. When omitted, the user picks from every operation\n   * of the plugin. When two commits share the id (two machines minted it before syncing), the user picks between\n   * them.\n   */\n  public async undoBulkOperation(operationId?: string): Promise<void> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.notActive));\n      return;\n    }\n\n    let commits = await repo.listBulkOperationCommits(this.pluginId);\n    if (operationId !== undefined) {\n      commits = commits.filter((commit) => commit.operationId === operationId);\n    }\n\n    if (commits.length === 0) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.noOperations));\n      return;\n    }\n\n    const commit = commits.length === 1 && operationId !== undefined\n      ? ensureNonNullable(commits[0])\n      : await selectItem({\n        app: this.app,\n        items: commits,\n        itemTextFunction: formatCommit,\n        placeholder: t(($) => $.obsidianLib.bulkOperation.selectOperation)\n      });\n    if (!commit) {\n      return;\n    }\n\n    let revertResult;\n    try {\n      revertResult = await repo.revertBulkOperationCommit(commit);\n    } catch (error) {\n      this.pluginNoticeComponent.showNotice(\n        t(($) => $.obsidianLib.bulkOperation.revertFailed, { error: errorToString(error), operationId: commit.operationId })\n      );\n      return;\n    }\n\n    if (revertResult.isConflict) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.revertConflict, { operationId: commit.operationId }), {\n        isPermanent: true\n      });\n      return;\n    }\n\n    this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.reverted, { operationId: commit.operationId }));\n  }\n\n  private async findRepo(): Promise<BulkOperationGitRepo | null> {\n    if (!Platform.isDesktopApp) {\n      return null;\n    }\n    const adapter = this.app.vault.adapter;\n    if (!(adapter instanceof FileSystemAdapter)) {\n      return null;\n    }\n    // Conditional import of the desktop-only git layer; this runs only on desktop, keeping its Node builtins off\n    // the mobile load path.\n    const { BulkOperationGitRepo: GitRepo } = await import('../desktop-bulk-operation-git.ts');\n    return await GitRepo.open(adapter.getBasePath());\n  }\n\n  private async getRepo(): Promise<BulkOperationGitRepo | null> {\n    if (!this.isEnabled()) {\n      return null;\n    }\n    this.repoPromise ??= this.findRepo();\n    return await this.repoPromise;\n  }\n\n  private async recoverStaleLock(): Promise<void> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      return;\n    }\n    const operationId = await repo.recoverStaleLock();\n    if (operationId !== null) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.recoveredInterrupted, { operationId }));\n    }\n  }\n\n  private async settle(): Promise<void> {\n    await flushQueue();\n    await waitForPendingLinkUpdates(this.app);\n    await ensureMetadataCacheReady(this.app);\n    await this.waitForQuietVault();\n  }\n\n  private async waitForQuietVault(): Promise<void> {\n    let lastChangeAt = performance.now();\n    const deadline = lastChangeAt + this.maxSettleTimeInMilliseconds;\n    function onChange(): void {\n      lastChangeAt = performance.now();\n    }\n    const eventRefs: EventRef[] = [\n      this.app.vault.on('create', onChange),\n      this.app.vault.on('delete', onChange),\n      this.app.vault.on('modify', onChange),\n      this.app.vault.on('rename', onChange)\n    ];\n    try {\n      for (;;) {\n        const now = performance.now();\n        const quietRemaining = lastChangeAt + this.quietPeriodInMilliseconds - now;\n        if (quietRemaining <= 0 || now >= deadline) {\n          return;\n        }\n        reportBulkOperationProgress();\n        await setTimeoutAsync(Math.min(quietRemaining, deadline - now));\n      }\n    } finally {\n      for (const eventRef of eventRefs) {\n        this.app.vault.offref(eventRef);\n      }\n    }\n  }\n}\n\nfunction formatCommit(commit: BulkOperationCommit): string {\n  return `${commit.subject} (${commit.date}, ${commit.sha.slice(0, SHORT_SHA_LENGTH)})`;\n}\n"],"mappings":"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","names":["commit"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/bulk-operation-commit-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains class {@link BulkOperationCommitComponent} that wraps a plugin's bulk operations in git commits, so\n * `git revert` undoes one.\n */\n\nimport type {\n  App,\n  EventRef\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  invokeAsyncSafely,\n  setTimeoutAsync\n} from '@mnaoumov/typescript-lib/async';\nimport { errorToString } from '@mnaoumov/typescript-lib/error';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport {\n  FileSystemAdapter,\n  Platform\n} from 'obsidian';\n\nimport type { BulkOperationCommit } from '../bulk-operation.ts';\nimport type { BulkOperationGitRepo } from '../desktop-bulk-operation-git.ts';\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\n\nimport { reportBulkOperationProgress } from '../bulk-operation-progress.ts';\nimport { getObsidianLibDebugger } from '../debug.ts';\nimport { waitForPendingLinkUpdates } from '../file-manager.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { ensureMetadataCacheReady } from '../metadata-cache.ts';\nimport { selectItem } from '../modals/select-item.ts';\nimport { flushQueue } from '../queue.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * Constructor parameters for {@link BulkOperationCommitComponent}.\n */\nexport interface BulkOperationCommitComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether the plugin's opt-in setting for bulk-operation commits is on. Read on every operation, so a settings\n   * change applies to the next one.\n   */\n  readonly isEnabled: () => boolean;\n\n  /**\n   * The longest the settle step waits for the vault to go quiet after an operation.\n   *\n   * @default `60_000`\n   */\n  readonly maxSettleTimeInMilliseconds?: number;\n\n  /**\n   * The id of the plugin whose operations are committed.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The notice component used to report problems.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * How long the vault must go without a change after an operation before its commit is made.\n   *\n   * @default `2000`\n   */\n  readonly quietPeriodInMilliseconds?: number;\n}\n\n/**\n * Parameters for {@link BulkOperationCommitComponent.runBulkOperation}.\n *\n * @typeParam T - The type of the operation's result.\n */\nexport interface BulkOperationCommitComponentRunBulkOperationParams<T> {\n  /**\n   * Runs the bulk operation.\n   *\n   * @returns The operation's result.\n   */\n  readonly operation: () => Promisable<T>;\n\n  /**\n   * A one-line description of the operation, used in the commit subject, such as `Collect attachments in Notes`.\n   */\n  readonly summary: string;\n}\n\nconst DEFAULT_MAX_SETTLE_TIME_IN_MILLISECONDS = 60_000;\nconst DEFAULT_QUIET_PERIOD_IN_MILLISECONDS = 2000;\nconst SHORT_SHA_LENGTH = 8;\n\n/**\n * Wraps a plugin's bulk operations in git commits, so `git revert` of one commit undoes one operation.\n *\n * @remarks\n * Opt-in through the plugin's own setting, and active only on desktop, for a vault inside a git work tree. When it\n * is not active, {@link runBulkOperation} simply runs the operation. When it is, the operation runs between a\n * `chore: before OP<n>` commit of whatever was pending and an `OP<n>: <summary>` commit of what it changed, under\n * a lease lock in the repo's git directory that the scheduled vault autocommit honors. The lock's heartbeat\n * is refreshed by the operation's progress: every `loop()` item, or an explicit `reportBulkOperationProgress()`.\n *\n * On load it recovers a lock left stale by a crash, committing the leftovers as `OP<n> interrupted`.\n *\n * Pair it with `UndoBulkOperationCommandHandler`, which lists the plugin's operations and reverts one.\n *\n * @example\n * ```ts\n * this.bulkOperationCommitComponent = this.addChild(new BulkOperationCommitComponent({\n *   app: this.app,\n *   isEnabled: () => this.settings.shouldCommitBulkOperations,\n *   pluginId: this.manifest.id,\n *   pluginNoticeComponent: this.pluginNoticeComponent\n * }));\n *\n * await this.bulkOperationCommitComponent.runBulkOperation({\n *   operation: () => collectAttachmentsInFolder(folder),\n *   summary: `Collect attachments in ${folder.path}`\n * });\n * ```\n */\nexport class BulkOperationCommitComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * Whether the plugin's opt-in setting is on.\n   */\n  protected readonly isEnabled: () => boolean;\n\n  /**\n   * The id of the plugin whose operations are committed.\n   */\n  protected readonly pluginId: string;\n\n  /**\n   * The notice component used to report problems.\n   */\n  protected readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  private readonly maxSettleTimeInMilliseconds: number;\n  private readonly quietPeriodInMilliseconds: number;\n  private repoPromise: null | Promise<BulkOperationGitRepo | null> = null;\n\n  /**\n   * Creates a new instance.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: BulkOperationCommitComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.isEnabled = params.isEnabled;\n    this.pluginId = params.pluginId;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.maxSettleTimeInMilliseconds = params.maxSettleTimeInMilliseconds ?? DEFAULT_MAX_SETTLE_TIME_IN_MILLISECONDS;\n    this.quietPeriodInMilliseconds = params.quietPeriodInMilliseconds ?? DEFAULT_QUIET_PERIOD_IN_MILLISECONDS;\n  }\n\n  /**\n   * Checks whether bulk operations are currently committed: the setting is on, the app is desktop and the vault is\n   * inside a git work tree.\n   *\n   * @returns Whether bulk operations are committed.\n   */\n  public async checkActive(): Promise<boolean> {\n    return await this.getRepo() !== null;\n  }\n\n  /**\n   * Recovers a stale lock left by a crashed operation once the component loads.\n   */\n  public override onload(): void {\n    super.onload();\n    invokeAsyncSafely(() => this.recoverStaleLock());\n  }\n\n  /**\n   * Runs a bulk operation, wrapped in git commits when bulk-operation commits are active.\n   *\n   * @typeParam T - The type of the operation's result.\n   * @param params - The parameters.\n   * @returns The operation's result.\n   */\n  public async runBulkOperation<T>(params: BulkOperationCommitComponentRunBulkOperationParams<T>): Promise<T> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      return await params.operation();\n    }\n\n    const { commitSha, operationId, recoveredOperationId, result } = await repo.runBulkOperation({\n      operation: async () => await params.operation(),\n      pluginId: this.pluginId,\n      settle: () => this.settle(),\n      summary: params.summary\n    });\n    getObsidianLibDebugger('BulkOperationCommitComponent')(\n      commitSha === null ? `${operationId} changed nothing` : `${operationId} committed as ${commitSha}`\n    );\n    if (recoveredOperationId !== null) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.resumedAfterRecovery, { operationId, recoveredOperationId }));\n    }\n    return result;\n  }\n\n  /**\n   * Lets the user pick one of the plugin's bulk operations and reverts its commit.\n   *\n   * A conflict is reported and left for the user to resolve; the revert is never aborted.\n   *\n   * @param operationId - The operation to undo, such as `OP12`. When omitted, the user picks from every operation\n   * of the plugin. When two commits share the id (two machines minted it before syncing), the user picks between\n   * them.\n   */\n  public async undoBulkOperation(operationId?: string): Promise<void> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.notActive));\n      return;\n    }\n\n    let commits = await repo.listBulkOperationCommits(this.pluginId);\n    if (operationId !== undefined) {\n      commits = commits.filter((commit) => commit.operationId === operationId);\n    }\n\n    if (commits.length === 0) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.noOperations));\n      return;\n    }\n\n    const commit = commits.length === 1 && operationId !== undefined\n      ? ensureNonNullable(commits[0])\n      : await selectItem({\n        app: this.app,\n        items: commits,\n        itemTextFunction: formatCommit,\n        placeholder: t(($) => $.obsidianLib.bulkOperation.selectOperation)\n      });\n    if (!commit) {\n      return;\n    }\n\n    let revertResult;\n    try {\n      revertResult = await repo.revertBulkOperationCommit(commit);\n    } catch (error) {\n      this.pluginNoticeComponent.showNotice(\n        t(($) => $.obsidianLib.bulkOperation.revertFailed, { error: errorToString(error), operationId: commit.operationId })\n      );\n      return;\n    }\n\n    if (revertResult.isConflict) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.revertConflict, { operationId: commit.operationId }), {\n        isPermanent: true\n      });\n      return;\n    }\n\n    this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.reverted, { operationId: commit.operationId }));\n  }\n\n  private async findRepo(): Promise<BulkOperationGitRepo | null> {\n    if (!Platform.isDesktopApp) {\n      return null;\n    }\n    const adapter = this.app.vault.adapter;\n    if (!(adapter instanceof FileSystemAdapter)) {\n      return null;\n    }\n    // Conditional import of the desktop-only git layer; this runs only on desktop, keeping its Node builtins off\n    // the mobile load path.\n    const { BulkOperationGitRepo: GitRepo } = await import('../desktop-bulk-operation-git.ts');\n    return await GitRepo.open(adapter.getBasePath());\n  }\n\n  private async getRepo(): Promise<BulkOperationGitRepo | null> {\n    if (!this.isEnabled()) {\n      return null;\n    }\n    this.repoPromise ??= this.findRepo();\n    return await this.repoPromise;\n  }\n\n  private async recoverStaleLock(): Promise<void> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      return;\n    }\n    const operationId = await repo.recoverStaleLock();\n    if (operationId !== null) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.recoveredInterrupted, { operationId }));\n    }\n  }\n\n  private async settle(): Promise<void> {\n    await flushQueue();\n    await waitForPendingLinkUpdates(this.app);\n    await ensureMetadataCacheReady(this.app);\n    await this.waitForQuietVault();\n  }\n\n  private async waitForQuietVault(): Promise<void> {\n    let lastChangeAt = performance.now();\n    const deadline = lastChangeAt + this.maxSettleTimeInMilliseconds;\n    function onChange(): void {\n      lastChangeAt = performance.now();\n    }\n    const eventRefs: EventRef[] = [\n      this.app.vault.on('create', onChange),\n      this.app.vault.on('delete', onChange),\n      this.app.vault.on('modify', onChange),\n      this.app.vault.on('rename', onChange)\n    ];\n    try {\n      for (;;) {\n        const now = performance.now();\n        const quietRemaining = lastChangeAt + this.quietPeriodInMilliseconds - now;\n        if (quietRemaining <= 0 || now >= deadline) {\n          return;\n        }\n        reportBulkOperationProgress();\n        await setTimeoutAsync(Math.min(quietRemaining, deadline - now));\n      }\n    } finally {\n      for (const eventRef of eventRefs) {\n        this.app.vault.offref(eventRef);\n      }\n    }\n  }\n}\n\nfunction formatCommit(commit: BulkOperationCommit): string {\n  return `${commit.subject} (${commit.date}, ${commit.sha.slice(0, SHORT_SHA_LENGTH)})`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,mBAGO;AACP,mBAA8B;AAC9B,yBAAkC;AAClC,sBAGO;AAMP,qCAA4C;AAC5C,mBAAuC;AACvC,0BAA0C;AAC1C,kBAAkB;AAClB,4BAAyC;AACzC,yBAA2B;AAC3B,mBAA2B;AAC3B,0BAA4B;AA6D5B,MAAM,0CAA0C;AAChD,MAAM,uCAAuC;AAC7C,MAAM,mBAAmB;AA+BlB,MAAM,qCAAqC,gCAAY;AAAA;AAAA;AAAA;AAAA,EAIzC;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,EAEF;AAAA,EACA;AAAA,EACT,cAA2D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO5D,YAAY,QAAuD;AACxE,UAAM;AACN,SAAK,MAAM,OAAO;AAClB,SAAK,YAAY,OAAO;AACxB,SAAK,WAAW,OAAO;AACvB,SAAK,wBAAwB,OAAO;AACpC,SAAK,8BAA8B,OAAO,+BAA+B;AACzE,SAAK,4BAA4B,OAAO,6BAA6B;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,cAAgC;AAC3C,WAAO,MAAM,KAAK,QAAQ,MAAM;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA,EAKgB,SAAe;AAC7B,UAAM,OAAO;AACb,wCAAkB,MAAM,KAAK,iBAAiB,CAAC;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,iBAAoB,QAA2E;AAC1G,UAAM,OAAO,MAAM,KAAK,QAAQ;AAChC,QAAI,CAAC,MAAM;AACT,aAAO,MAAM,OAAO,UAAU;AAAA,IAChC;AAEA,UAAM,EAAE,WAAW,aAAa,sBAAsB,OAAO,IAAI,MAAM,KAAK,iBAAiB;AAAA,MAC3F,WAAW,YAAY,MAAM,OAAO,UAAU;AAAA,MAC9C,UAAU,KAAK;AAAA,MACf,QAAQ,MAAM,KAAK,OAAO;AAAA,MAC1B,SAAS,OAAO;AAAA,IAClB,CAAC;AACD,6CAAuB,8BAA8B;AAAA,MACnD,cAAc,OAAO,GAAG,WAAW,qBAAqB,GAAG,WAAW,iBAAiB,SAAS;AAAA,IAClG;AACA,QAAI,yBAAyB,MAAM;AACjC,WAAK,sBAAsB,eAAW,eAAE,CAAC,MAAM,EAAE,YAAY,cAAc,sBAAsB,EAAE,aAAa,qBAAqB,CAAC,CAAC;AAAA,IACzI;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAa,kBAAkB,aAAqC;AAClE,UAAM,OAAO,MAAM,KAAK,QAAQ;AAChC,QAAI,CAAC,MAAM;AACT,WAAK,sBAAsB,eAAW,eAAE,CAAC,MAAM,EAAE,YAAY,cAAc,SAAS,CAAC;AACrF;AAAA,IACF;AAEA,QAAI,UAAU,MAAM,KAAK,yBAAyB,KAAK,QAAQ;AAC/D,QAAI,gBAAgB,QAAW;AAC7B,gBAAU,QAAQ,OAAO,CAACA,YAAWA,QAAO,gBAAgB,WAAW;AAAA,IACzE;AAEA,QAAI,QAAQ,WAAW,GAAG;AACxB,WAAK,sBAAsB,eAAW,eAAE,CAAC,MAAM,EAAE,YAAY,cAAc,YAAY,CAAC;AACxF;AAAA,IACF;AAEA,UAAM,SAAS,QAAQ,WAAW,KAAK,gBAAgB,aACnD,sCAAkB,QAAQ,CAAC,CAAC,IAC5B,UAAM,+BAAW;AAAA,MACjB,KAAK,KAAK;AAAA,MACV,OAAO;AAAA,MACP,kBAAkB;AAAA,MAClB,iBAAa,eAAE,CAAC,MAAM,EAAE,YAAY,cAAc,eAAe;AAAA,IACnE,CAAC;AACH,QAAI,CAAC,QAAQ;AACX;AAAA,IACF;AAEA,QAAI;AACJ,QAAI;AACF,qBAAe,MAAM,KAAK,0BAA0B,MAAM;AAAA,IAC5D,SAAS,OAAO;AACd,WAAK,sBAAsB;AAAA,YACzB,eAAE,CAAC,MAAM,EAAE,YAAY,cAAc,cAAc,EAAE,WAAO,4BAAc,KAAK,GAAG,aAAa,OAAO,YAAY,CAAC;AAAA,MACrH;AACA;AAAA,IACF;AAEA,QAAI,aAAa,YAAY;AAC3B,WAAK,sBAAsB,eAAW,eAAE,CAAC,MAAM,EAAE,YAAY,cAAc,gBAAgB,EAAE,aAAa,OAAO,YAAY,CAAC,GAAG;AAAA,QAC/H,aAAa;AAAA,MACf,CAAC;AACD;AAAA,IACF;AAEA,SAAK,sBAAsB,eAAW,eAAE,CAAC,MAAM,EAAE,YAAY,cAAc,UAAU,EAAE,aAAa,OAAO,YAAY,CAAC,CAAC;AAAA,EAC3H;AAAA,EAEA,MAAc,WAAiD;AAC7D,QAAI,CAAC,yBAAS,cAAc;AAC1B,aAAO;AAAA,IACT;AACA,UAAM,UAAU,KAAK,IAAI,MAAM;AAC/B,QAAI,EAAE,mBAAmB,oCAAoB;AAC3C,aAAO;AAAA,IACT;AAGA,UAAM,EAAE,sBAAsB,QAAQ,IAAI,MAAM,OAAO,kCAAkC;AACzF,WAAO,MAAM,QAAQ,KAAK,QAAQ,YAAY,CAAC;AAAA,EACjD;AAAA,EAEA,MAAc,UAAgD;AAC5D,QAAI,CAAC,KAAK,UAAU,GAAG;AACrB,aAAO;AAAA,IACT;AACA,SAAK,gBAAgB,KAAK,SAAS;AACnC,WAAO,MAAM,KAAK;AAAA,EACpB;AAAA,EAEA,MAAc,mBAAkC;AAC9C,UAAM,OAAO,MAAM,KAAK,QAAQ;AAChC,QAAI,CAAC,MAAM;AACT;AAAA,IACF;AACA,UAAM,cAAc,MAAM,KAAK,iBAAiB;AAChD,QAAI,gBAAgB,MAAM;AACxB,WAAK,sBAAsB,eAAW,eAAE,CAAC,MAAM,EAAE,YAAY,cAAc,sBAAsB,EAAE,YAAY,CAAC,CAAC;AAAA,IACnH;AAAA,EACF;AAAA,EAEA,MAAc,SAAwB;AACpC,cAAM,yBAAW;AACjB,cAAM,+CAA0B,KAAK,GAAG;AACxC,cAAM,gDAAyB,KAAK,GAAG;AACvC,UAAM,KAAK,kBAAkB;AAAA,EAC/B;AAAA,EAEA,MAAc,oBAAmC;AAC/C,QAAI,eAAe,YAAY,IAAI;AACnC,UAAM,WAAW,eAAe,KAAK;AACrC,aAAS,WAAiB;AACxB,qBAAe,YAAY,IAAI;AAAA,IACjC;AACA,UAAM,YAAwB;AAAA,MAC5B,KAAK,IAAI,MAAM,GAAG,UAAU,QAAQ;AAAA,MACpC,KAAK,IAAI,MAAM,GAAG,UAAU,QAAQ;AAAA,MACpC,KAAK,IAAI,MAAM,GAAG,UAAU,QAAQ;AAAA,MACpC,KAAK,IAAI,MAAM,GAAG,UAAU,QAAQ;AAAA,IACtC;AACA,QAAI;AACF,iBAAS;AACP,cAAM,MAAM,YAAY,IAAI;AAC5B,cAAM,iBAAiB,eAAe,KAAK,4BAA4B;AACvE,YAAI,kBAAkB,KAAK,OAAO,UAAU;AAC1C;AAAA,QACF;AACA,wEAA4B;AAC5B,kBAAM,8BAAgB,KAAK,IAAI,gBAAgB,WAAW,GAAG,CAAC;AAAA,MAChE;AAAA,IACF,UAAE;AACA,iBAAW,YAAY,WAAW;AAChC,aAAK,IAAI,MAAM,OAAO,QAAQ;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,aAAa,QAAqC;AACzD,SAAO,GAAG,OAAO,OAAO,KAAK,OAAO,IAAI,KAAK,OAAO,IAAI,MAAM,GAAG,gBAAgB,CAAC;AACpF;","names":["commit"]}