@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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

@@ -0,0 +1,270 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Resolves, searches and manages community plugins through Obsidian's public plugin registry and
+ * store-install path.
+ *
+ * Obsidian's `community-plugins.json` is the authoritative source that maps a plugin `id` to its
+ * `owner/name` GitHub repository — the plugin manifest itself carries no repository. This module uses
+ * it to search the registry, to locate a plugin's GitHub releases (e.g. to download its shipped
+ * demo-vault archive), and to install/uninstall/enable/disable an arbitrary community plugin — selected
+ * by either its `id` or its display `name` — via Obsidian's own store path (`app.plugins.installPlugin`
+ * + `enablePluginAndSave`), so any dev/deploy or tooling flow can reuse it.
+ */
+import type { App } from 'obsidian';
+/**
+ * Selects a community plugin either by its id ({@link CommunityPluginByIdRef}) or by its display name
+ * ({@link CommunityPluginByNameRef}).
+ */
+export type CommunityPluginRef = CommunityPluginByIdRef | CommunityPluginByNameRef;
+/**
+ * A single result of {@link searchCommunityPlugins}.
+ */
+export interface CommunityPluginSearchResult {
+    /**
+     * The plugin id.
+     */
+    readonly id: string;
+    /**
+     * The plugin display name.
+     */
+    readonly name: string;
+}
+/**
+ * Parameters for {@link configureCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type ConfigureCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginSettings;
+/**
+ * Parameters for {@link disableCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type DisableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;
+/**
+ * Parameters for {@link enableCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type EnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;
+/**
+ * Parameters for {@link installCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type InstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;
+/**
+ * Parameters for {@link installConfigureEnableCommunityPlugin}. Selects the plugin by either `pluginId`
+ * or `pluginName`; `settings` is optional (omit for a plugin that needs no configuration).
+ */
+export type InstallConfigureEnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & Partial<CommunityPluginSettings>;
+/**
+ * Parameters for {@link toggleEnableCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type ToggleEnableCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginToggleEnableState;
+/**
+ * Parameters for {@link toggleInstallCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type ToggleInstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef & CommunityPluginToggleInstallState;
+/**
+ * Parameters for {@link uninstallCommunityPlugin}. Selects the plugin by either `pluginId` or
+ * `pluginName`.
+ */
+export type UninstallCommunityPluginParams = CommunityPluginOperationContext & CommunityPluginRef;
+/**
+ * Selects a community plugin by its id.
+ */
+interface CommunityPluginByIdRef {
+    /**
+     * The plugin id.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Selects a community plugin by its display name (as listed in Obsidian's community registry).
+ */
+interface CommunityPluginByNameRef {
+    /**
+     * The plugin display name.
+     */
+    readonly pluginName: string;
+}
+/**
+ * The Obsidian app instance a community-plugin operation runs against.
+ */
+interface CommunityPluginOperationContext {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+}
+/**
+ * The settings to merge into a community plugin's `data.json`.
+ */
+interface CommunityPluginSettings {
+    /**
+     * The settings object shallow-merged over the plugin's existing `data.json` (the file is created if
+     * absent).
+     */
+    readonly settings: object;
+}
+/**
+ * The desired enabled state for {@link toggleEnableCommunityPlugin}.
+ */
+interface CommunityPluginToggleEnableState {
+    /**
+     * The desired enabled state: `true` enables the plugin, `false` disables it.
+     */
+    readonly isEnabled: boolean;
+}
+/**
+ * The desired installed state for {@link toggleInstallCommunityPlugin}.
+ */
+interface CommunityPluginToggleInstallState {
+    /**
+     * The desired installed state: `true` installs the plugin, `false` uninstalls it.
+     */
+    readonly isInstalled: boolean;
+}
+/**
+ * The result of {@link configureCommunityPlugin}.
+ */
+export declare enum ConfigureCommunityPluginResult {
+    /**
+     * The settings were applied through the running plugin's own settings component, which both updated
+     * them in memory and persisted them. The plugin is already using them, so it must NOT be reloaded.
+     */
+    AppliedLive = "appliedLive",
+    /**
+     * The settings were already present in the plugin's `data.json`, so nothing was written.
+     */
+    Skipped = "skipped",
+    /**
+     * The settings were merged into the plugin's `data.json`, which was written.
+     */
+    Success = "success"
+}
+/**
+ * Configures a community plugin, preferring the running plugin's own settings component over its
+ * `data.json`.
+ *
+ * When the plugin is loaded AND exposes a `pluginSettingsComponent` with an `editAndSave` method, the
+ * settings are shallow-merged through it: they take effect immediately and are persisted, so the plugin
+ * needs no reload and {@link ConfigureCommunityPluginResult.AppliedLive} is returned. This is what lets a
+ * plugin's own script reconfigure it without the disable/enable cycle that would tear down the very code
+ * doing the reconfiguring. Note that this path runs the plugin's setting validators, so an invalid value
+ * is replaced by its default rather than written through verbatim.
+ *
+ * Otherwise the settings are written into the plugin's `data.json`, shallow-merged over any existing
+ * settings (creating the file if absent). Writing settings BEFORE the plugin is enabled makes it load
+ * already configured, with no reload. A no-op write is skipped: when the merge changes nothing, the file
+ * is left untouched and {@link ConfigureCommunityPluginResult.Skipped} is returned, so a caller can avoid
+ * reloading an already-correctly-configured plugin.
+ *
+ * @param params - The {@link ConfigureCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves to {@link ConfigureCommunityPluginResult.AppliedLive} if the
+ * running plugin applied them itself (no reload needed), {@link ConfigureCommunityPluginResult.Success} if
+ * the `data.json` content changed (and was written), or {@link ConfigureCommunityPluginResult.Skipped} if
+ * the settings were already present (nothing written).
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function configureCommunityPlugin(params: ConfigureCommunityPluginParams): Promise<ConfigureCommunityPluginResult>;
+/**
+ * Disables a community plugin (persisting the change) if it is currently enabled. Idempotent — a no-op
+ * when the plugin is already disabled.
+ *
+ * @param params - The {@link DisableCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is disabled.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function disableCommunityPlugin(params: DisableCommunityPluginParams): Promise<void>;
+/**
+ * Enables a community plugin (persisting the change) if it is not already enabled. Idempotent — a no-op
+ * when the plugin is already enabled.
+ *
+ * @param params - The {@link EnableCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is enabled.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function enableCommunityPlugin(params: EnableCommunityPluginParams): Promise<void>;
+/**
+ * Resolves the `owner/name` GitHub repository of a community plugin from Obsidian's public
+ * `community-plugins.json` registry.
+ *
+ * The registry is fetched once and cached on the shared plugin state for subsequent calls; a failed
+ * fetch is not cached, so a later call retries.
+ *
+ * @param pluginId - The plugin id to look up.
+ * @returns A {@link Promise} resolving to the plugin's `owner/name` repository, or `null` if the
+ * plugin is not listed in the registry.
+ */
+export declare function getCommunityPluginRepo(pluginId: string): Promise<null | string>;
+/**
+ * Resolves the latest release version (the release `tag_name`, a bare version such as `1.2.3`) of a
+ * GitHub repository.
+ *
+ * @param repo - The `owner/name` GitHub repository.
+ * @returns A {@link Promise} resolving to the latest release version.
+ */
+export declare function getLatestReleaseVersion(repo: string): Promise<string>;
+/**
+ * Installs a community plugin from the official store if it is not already installed. Idempotent — a
+ * no-op when the plugin is already installed. Resolves the plugin's repository from Obsidian's
+ * community registry, reads the latest release version and its manifest, and installs it through
+ * Obsidian's own `installPlugin` path.
+ *
+ * @param params - The {@link InstallCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is installed.
+ * @throws If the plugin is not listed in Obsidian's community plugins registry.
+ */
+export declare function installCommunityPlugin(params: InstallCommunityPluginParams): Promise<void>;
+/**
+ * Installs a community plugin, writes its settings, THEN enables it — in that order — so the plugin
+ * loads already configured (a plugin enabled before it is configured runs its `onload` with default
+ * settings and does nothing useful). If the plugin is already enabled and the settings changed, it is
+ * disabled and re-enabled so the new settings take effect. `settings` is optional: omit it for a plugin
+ * that needs no configuration. Composes {@link installCommunityPlugin}, {@link configureCommunityPlugin},
+ * {@link enableCommunityPlugin} and {@link disableCommunityPlugin}.
+ *
+ * @param params - The {@link InstallConfigureEnableCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is installed, configured and enabled.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function installConfigureEnableCommunityPlugin(params: InstallConfigureEnableCommunityPluginParams): Promise<void>;
+/**
+ * Searches Obsidian's public community plugins registry, returning the id and display name of every
+ * plugin whose id, name, author or description contains the query (case-insensitive). An empty query
+ * matches every plugin.
+ *
+ * @param query - The search query.
+ * @returns A {@link Promise} resolving to the matching plugins' {@link CommunityPluginSearchResult}s.
+ */
+export declare function searchCommunityPlugins(query: string): Promise<CommunityPluginSearchResult[]>;
+/**
+ * Enables or disables a community plugin to match the desired state. Delegates to
+ * {@link enableCommunityPlugin} / {@link disableCommunityPlugin}, so it is idempotent.
+ *
+ * @param params - The {@link ToggleEnableCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin matches the desired enabled state.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function toggleEnableCommunityPlugin(params: ToggleEnableCommunityPluginParams): Promise<void>;
+/**
+ * Installs or uninstalls a community plugin to match the desired state. Delegates to
+ * {@link installCommunityPlugin} / {@link uninstallCommunityPlugin}, so it is idempotent.
+ *
+ * @param params - The {@link ToggleInstallCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin matches the desired installed state.
+ * @throws If installing and the plugin is not listed in Obsidian's community plugins registry.
+ */
+export declare function toggleInstallCommunityPlugin(params: ToggleInstallCommunityPluginParams): Promise<void>;
+/**
+ * Uninstalls a community plugin if it is currently installed. Idempotent — a no-op when the plugin is
+ * not installed.
+ *
+ * @param params - The {@link UninstallCommunityPluginParams}.
+ * @returns A {@link Promise} that resolves once the plugin is uninstalled.
+ * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.
+ */
+export declare function uninstallCommunityPlugin(params: UninstallCommunityPluginParams): Promise<void>;
+export {};

package/dist/lib/esm/community-plugins.mjs

@@ -0,0 +1,222 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { requestUrl } from "obsidian";
+import { getObsidianDevUtilsState } from "./obsidian-dev-utils-state.mjs";
+const COMMUNITY_PLUGINS_STATE_KEY = "communityPluginEntriesPromise";
+const COMMUNITY_PLUGINS_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
+const DATA_JSON_INDENT = 2;
+var ConfigureCommunityPluginResult = /* @__PURE__ */ ((ConfigureCommunityPluginResult2) => {
+  ConfigureCommunityPluginResult2["AppliedLive"] = "appliedLive";
+  ConfigureCommunityPluginResult2["Skipped"] = "skipped";
+  ConfigureCommunityPluginResult2["Success"] = "success";
+  return ConfigureCommunityPluginResult2;
+})(ConfigureCommunityPluginResult || {});
+async function configureCommunityPlugin(params) {
+  const { app, settings } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  const settingsComponent = getSettingsComponent(app.plugins.plugins[pluginId]);
+  if (checkHasEditAndSave(settingsComponent)) {
+    await settingsComponent.editAndSave((pluginSettings) => {
+      Object.assign(pluginSettings, settings);
+    });
+    return "appliedLive" /* AppliedLive */;
+  }
+  const dataPath = `${app.vault.configDir}/plugins/${pluginId}/data.json`;
+  let data = {};
+  if (await app.vault.adapter.exists(dataPath)) {
+    const parsed = JSON.parse(await app.vault.adapter.read(dataPath));
+    if (parsed !== null && typeof parsed === "object") {
+      data = parsed;
+    }
+  }
+  const serializedBefore = JSON.stringify(data);
+  Object.assign(data, settings);
+  if (JSON.stringify(data) === serializedBefore) {
+    return "skipped" /* Skipped */;
+  }
+  const serialized = String(JSON.stringify(data, null, DATA_JSON_INDENT));
+  await app.vault.adapter.write(dataPath, `${serialized}
+`);
+  return "success" /* Success */;
+}
+async function disableCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (!app.plugins.enabledPlugins.has(pluginId)) {
+    return;
+  }
+  await app.plugins.disablePluginAndSave(pluginId);
+}
+async function enableCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (app.plugins.enabledPlugins.has(pluginId)) {
+    return;
+  }
+  await app.plugins.enablePluginAndSave(pluginId);
+}
+async function getCommunityPluginRepo(pluginId) {
+  const entries = await getCommunityPluginEntries();
+  const entry = entries.find((candidate) => candidate.id === pluginId);
+  return entry?.repo ?? null;
+}
+async function getLatestReleaseVersion(repo) {
+  const response = await requestUrl(`https://api.github.com/repos/${repo}/releases/latest`);
+  const release = response.json;
+  return release.tag_name;
+}
+async function installCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (Object.hasOwn(app.plugins.manifests, pluginId)) {
+    return;
+  }
+  const repo = await getCommunityPluginRepo(pluginId);
+  if (!repo) {
+    throw new Error(`Plugin '${pluginId}' was not found in the Obsidian community plugins registry.`);
+  }
+  const version = await getLatestReleaseVersion(repo);
+  const manifest = await getPluginManifest(repo, version);
+  await app.plugins.installPlugin(repo, version, manifest);
+}
+async function installConfigureEnableCommunityPlugin(params) {
+  const { app, settings } = params;
+  await installCommunityPlugin(params);
+  const didSettingsChange = settings ? await configureCommunityPlugin({ ...params, settings }) === "success" /* Success */ : false;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (!app.plugins.enabledPlugins.has(pluginId)) {
+    await enableCommunityPlugin(params);
+  } else if (didSettingsChange) {
+    await disableCommunityPlugin(params);
+    await enableCommunityPlugin(params);
+  }
+}
+async function searchCommunityPlugins(query) {
+  const entries = await getCommunityPluginEntries();
+  const normalizedQuery = query.toLowerCase();
+  return entries.filter(
+    (entry) => entry.id.toLowerCase().includes(normalizedQuery) || entry.name.toLowerCase().includes(normalizedQuery) || entry.author.toLowerCase().includes(normalizedQuery) || entry.description.toLowerCase().includes(normalizedQuery)
+  ).map((entry) => ({
+    id: entry.id,
+    name: entry.name
+  }));
+}
+async function toggleEnableCommunityPlugin(params) {
+  if (params.isEnabled) {
+    await enableCommunityPlugin(params);
+  } else {
+    await disableCommunityPlugin(params);
+  }
+}
+async function toggleInstallCommunityPlugin(params) {
+  if (params.isInstalled) {
+    await installCommunityPlugin(params);
+  } else {
+    await uninstallCommunityPlugin(params);
+  }
+}
+async function uninstallCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (!Object.hasOwn(app.plugins.manifests, pluginId)) {
+    return;
+  }
+  await app.plugins.uninstallPlugin(pluginId);
+}
+function checkHasEditAndSave(settingsComponent) {
+  return typeof settingsComponent === "object" && settingsComponent !== null && "editAndSave" in settingsComponent && typeof settingsComponent.editAndSave === "function";
+}
+async function fetchCommunityPluginEntries() {
+  const response = await requestUrl(COMMUNITY_PLUGINS_URL);
+  return response.json;
+}
+async function getCommunityPluginEntries() {
+  const cache = getObsidianDevUtilsState(COMMUNITY_PLUGINS_STATE_KEY, null);
+  cache.value ??= fetchCommunityPluginEntries();
+  try {
+    return await cache.value;
+  } catch (error) {
+    cache.value = null;
+    throw error;
+  }
+}
+async function getPluginManifest(repo, version) {
+  const response = await requestUrl(`https://github.com/${repo}/releases/download/${version}/manifest.json`);
+  return response.json;
+}
+function getSettingsComponent(plugin) {
+  return typeof plugin !== "object" || plugin === null || !("pluginSettingsComponent" in plugin) ? null : plugin.pluginSettingsComponent;
+}
+async function resolveCommunityPluginId(reference) {
+  if ("pluginId" in reference) {
+    return reference.pluginId;
+  }
+  const entries = await getCommunityPluginEntries();
+  const entry = entries.find((candidate) => candidate.name === reference.pluginName);
+  if (!entry) {
+    throw new Error(`Plugin named '${reference.pluginName}' was not found in the Obsidian community plugins registry.`);
+  }
+  return entry.id;
+}
+export {
+  ConfigureCommunityPluginResult,
+  configureCommunityPlugin,
+  disableCommunityPlugin,
+  enableCommunityPlugin,
+  getCommunityPluginRepo,
+  getLatestReleaseVersion,
+  installCommunityPlugin,
+  installConfigureEnableCommunityPlugin,
+  searchCommunityPlugins,
+  toggleEnableCommunityPlugin,
+  toggleInstallCommunityPlugin,
+  uninstallCommunityPlugin
+};
+//# 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 \u2014 the plugin manifest itself carries no repository. This module uses\n * it to search the registry, to locate a plugin's GitHub releases (e.g. to download its shipped\n * demo-vault archive), and to install/uninstall/enable/disable an arbitrary community plugin \u2014 selected\n * by either its `id` or its display `name` \u2014 via Obsidian's own store path (`app.plugins.installPlugin`\n * + `enablePluginAndSave`), so any dev/deploy or tooling flow can reuse it.\n */\n\nimport type {\n  App,\n  PluginManifest\n} from 'obsidian';\n\nimport { requestUrl } from 'obsidian';\n\nimport { getObsidianDevUtilsState } from './obsidian-dev-utils-state.ts';\n\n/**\n * Selects a community plugin either by its id ({@link CommunityPluginByIdRef}) or by its display name\n * ({@link CommunityPluginByNameRef}).\n */\nexport type CommunityPluginRef = CommunityPluginByIdRef | CommunityPluginByNameRef;\n\n/**\n * A single result of {@link searchCommunityPlugins}.\n */\nexport interface CommunityPluginSearchResult {\n  /**\n   * The plugin id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin display name.\n   */\n  readonly name: string;\n}\n\n/**\n * Parameters for {@link 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 * 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  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 * 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 \u2014 a no-op\n * when the plugin is already disabled.\n *\n * @param params - The {@link DisableCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is disabled.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function disableCommunityPlugin(params: DisableCommunityPluginParams): Promise<void> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (!app.plugins.enabledPlugins.has(pluginId)) {\n    return;\n  }\n  await app.plugins.disablePluginAndSave(pluginId);\n}\n\n/**\n * Enables a community plugin (persisting the change) if it is not already enabled. Idempotent \u2014 a no-op\n * when the plugin is already enabled.\n *\n * @param params - The {@link EnableCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is enabled.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function enableCommunityPlugin(params: EnableCommunityPluginParams): Promise<void> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (app.plugins.enabledPlugins.has(pluginId)) {\n    return;\n  }\n  await app.plugins.enablePluginAndSave(pluginId);\n}\n\n/**\n * Resolves the `owner/name` GitHub repository of a community plugin from Obsidian's public\n * `community-plugins.json` registry.\n *\n * The registry is fetched once and cached on the shared plugin state for subsequent calls; a failed\n * fetch is not cached, so a later call retries.\n *\n * @param pluginId - The plugin id to look up.\n * @returns A {@link Promise} resolving to the plugin's `owner/name` repository, or `null` if the\n * plugin is not listed in the registry.\n */\nexport async function getCommunityPluginRepo(pluginId: string): Promise<null | string> {\n  const entries = await getCommunityPluginEntries();\n  const entry = entries.find((candidate) => candidate.id === pluginId);\n  return entry?.repo ?? null;\n}\n\n/**\n * Resolves the latest release version (the release `tag_name`, a bare version such as `1.2.3`) of a\n * GitHub repository.\n *\n * @param repo - The `owner/name` GitHub repository.\n * @returns A {@link Promise} resolving to the latest release version.\n */\nexport async function getLatestReleaseVersion(repo: string): Promise<string> {\n  const response = await requestUrl(`https://api.github.com/repos/${repo}/releases/latest`);\n  const release = response.json as GitHubRelease;\n  return release.tag_name;\n}\n\n/**\n * Installs a community plugin from the official store if it is not already installed. Idempotent \u2014 a\n * no-op when the plugin is already installed. Resolves the plugin's repository from Obsidian's\n * community registry, reads the latest release version and its manifest, and installs it through\n * Obsidian's own `installPlugin` path.\n *\n * @param params - The {@link InstallCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is installed.\n * @throws If the plugin is not listed in Obsidian's community plugins registry.\n */\nexport async function installCommunityPlugin(params: InstallCommunityPluginParams): Promise<void> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (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 \u2014 in that order \u2014 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 \u2014 a no-op when the plugin is\n * not installed.\n *\n * @param params - The {@link UninstallCommunityPluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is uninstalled.\n * @throws If selected by `pluginName` and the name is not listed in Obsidian's community plugins registry.\n */\nexport async function uninstallCommunityPlugin(params: UninstallCommunityPluginParams): Promise<void> {\n  const { app } = params;\n  const pluginId = await resolveCommunityPluginId(params);\n  if (!Object.hasOwn(app.plugins.manifests, pluginId)) {\n    return;\n  }\n  await app.plugins.uninstallPlugin(pluginId);\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 = getObsidianDevUtilsState<null | Promise<CommunityPluginEntry[]>>(COMMUNITY_PLUGINS_STATE_KEY, null);\n  cache.value ??= fetchCommunityPluginEntries();\n\n  try {\n    return await cache.value;\n  } catch (error) {\n    cache.value = null;\n    throw error;\n  }\n}\n\nasync function getPluginManifest(repo: string, version: string): Promise<PluginManifest> {\n  const response = await requestUrl(`https://github.com/${repo}/releases/download/${version}/manifest.json`);\n  return response.json as PluginManifest;\n}\n\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\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"]
}


package/dist/lib/esm/components/abort-signal-component.d.mts

@@ -0,0 +1,30 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Component that provides an AbortSignal for cancelling long-running operations on plugin unload.
+ */
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * Provides an {@link AbortSignal} that is aborted when the component is unloaded.
+ */
+export declare class AbortSignalComponent extends ComponentEx {
+    protected readonly pluginId: string;
+    /**
+     * The abort signal.
+     *
+     * @returns The {@link AbortSignal} that is aborted when the component is unloaded.
+     */
+    get abortSignal(): AbortSignal;
+    private readonly abortController;
+    /**
+     * Creates a new abort signal component.
+     *
+     * @param pluginId - The plugin ID (used in the abort reason message).
+     */
+    constructor(pluginId: string);
+    /**
+     * Aborts the signal on unload.
+     */
+    onunload(): void;
+}