@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

package/dist/lib/esm/plugin/third-party-plugin.d.mts

@@ -0,0 +1,244 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Typed access to the API of a THIRD-PARTY plugin: one that publishes nothing through this library's registry.
+ *
+ * A plugin built on this library publishes a versioned contract (`getPluginApis()`), and a consumer reaches it
+ * through `watchPluginApi` (`./plugin-api.ts`). Most plugins a consumer wants to talk to — `Dataview`,
+ * `Templater`, `Notebook Navigator` — are not built on it, so their API hangs off the plugin instance under a
+ * name of their own choosing, and every consumer used to reach it by hand through `app.plugins` with a cast.
+ *
+ * A {@link ThirdPartyPluginAdapter} says ONCE, for one plugin, how to get from its instance to its typed API,
+ * and VERIFIES the shape on the way, so a release that renamed what the adapter reads is "not there" rather
+ * than a `Cannot read properties of undefined` from inside a callback. Everything else here is generic:
+ *
+ * - {@link getThirdPartyPluginApi} answers "now", for a one-shot use.
+ * - {@link watchThirdPartyPluginApi} answers "now" for as long as a component lives: its ref re-reads on every
+ *   `app.plugins` `changed` and every `obsidian-lib:plugin-loaded` / `-unloaded` broadcast, so an OPTIONAL
+ *   dependency is a ref whose `value` is `null` while the plugin is absent, and becomes the API the moment it
+ *   is enabled.
+ * - {@link waitForThirdPartyPluginApi} and {@link requireThirdPartyPluginApi} are the one-shot waits, built on
+ *   `waitForPlugin` / `requirePlugin` (`./plugin-instance.ts`), so they share that module's availability
+ *   classification, its notice and its repair buttons.
+ * - A REQUIRED dependency is declared through `PluginBase.getPluginDependencies()` as a
+ *   {@link ThirdPartyPluginDependency} (built by {@link createThirdPartyPluginDependency}), and the plugin gate
+ *   keeps `onloadImpl` from running while it is missing, too old or the wrong shape — the same treatment an
+ *   own-plugin dependency gets.
+ *
+ * Availability is {@link PluginAvailability}, read from Obsidian `1.15.1` as `plugin-instance.ts` documents:
+ * an instance whose `onload` is still running reads as `loading`, never as available. An adapter's
+ * `getApi` returning `null` reads as {@link PluginAvailability.ShapeMismatch}.
+ */
+import type { AsyncEventSource } from '@mnaoumov/typescript-lib/async-events';
+import type { App, Component, Plugin } from 'obsidian';
+import type { Except } from 'type-fest';
+import type { PluginDependencyBase } from '../components/plugin-gate-component.mjs';
+import type { RequirePluginParams, WaitForPluginParams } from './plugin-instance.mjs';
+import { PluginAvailability } from './plugin-instance.mjs';
+/**
+ * Parameters for {@link createThirdPartyPluginDependency}.
+ *
+ * @typeParam TApi - The adapter's API type.
+ */
+export interface CreateThirdPartyPluginDependencyParams<TApi extends object> {
+    /**
+     * The adapter of the required plugin.
+     */
+    readonly adapter: ThirdPartyPluginAdapter<TApi>;
+    /**
+     * The oldest release the dependent works with. Defaults to the adapter's own
+     * {@link ThirdPartyPluginAdapter.minPluginVersion}; a dependent may only raise it.
+     */
+    readonly minPluginVersion?: string;
+    /**
+     * A localized sentence saying what the dependent does with the plugin, shown in the settings banner.
+     */
+    readonly reason: DocumentFragment | string;
+}
+/**
+ * Parameters for {@link getThirdPartyPluginApi} and {@link getThirdPartyPluginAvailability}.
+ *
+ * @typeParam TApi - The adapter's API type.
+ */
+export interface GetThirdPartyPluginApiParams<TApi extends object> {
+    /**
+     * The adapter of the plugin.
+     */
+    readonly adapter: ThirdPartyPluginAdapter<TApi>;
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The oldest release the caller works with. Defaults to the adapter's own
+     * {@link ThirdPartyPluginAdapter.minPluginVersion}.
+     */
+    readonly minPluginVersion?: string;
+}
+/**
+ * Parameters for {@link getThirdPartyPluginAvailability}.
+ *
+ * @typeParam TApi - The adapter's API type.
+ */
+export type GetThirdPartyPluginAvailabilityParams<TApi extends object> = GetThirdPartyPluginApiParams<TApi>;
+/**
+ * Parameters for {@link requireThirdPartyPluginApi}.
+ *
+ * @typeParam TApi - The adapter's API type.
+ */
+export interface RequireThirdPartyPluginApiParams<TApi extends object> extends Except<RequirePluginParams, 'app' | 'isPlugin' | 'minPluginVersion' | 'pluginId' | 'pluginName'>, GetThirdPartyPluginApiParams<TApi> {
+}
+/**
+ * How to get from one third-party plugin's instance to its typed API.
+ *
+ * An adapter is plain data plus one function, so it can be a module-level constant shared by every consumer,
+ * and adding a plugin means adding one adapter.
+ *
+ * @typeParam TApi - The plugin's API, typed by the adapter's author and verified by {@link getApi}.
+ */
+export interface ThirdPartyPluginAdapter<TApi extends object> {
+    /**
+     * Reads the typed API off a running instance of the plugin, VERIFYING its shape.
+     *
+     * Return `null` when the instance does not carry the members the adapter types, which is what a release
+     * that renamed or reshaped them looks like. Never cast: a cast asserts a shape nothing checked.
+     *
+     * @param plugin - The running instance, whose `onload` has settled.
+     * @returns The API, or `null` when the instance is not the shape the adapter expects.
+     */
+    readonly getApi: (plugin: Plugin) => null | TApi;
+    /**
+     * The oldest release of the plugin the adapter was verified against, compared with its `manifest.version`.
+     * A release below it reads as {@link PluginAvailability.Outdated}.
+     */
+    readonly minPluginVersion?: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The display name of the plugin, shown to the user.
+     */
+    readonly pluginName: string;
+}
+/**
+ * A live reference to a third-party plugin's API.
+ *
+ * @typeParam TApi - The adapter's API type.
+ */
+export interface ThirdPartyPluginApiRef<TApi extends object> extends AsyncEventSource<ThirdPartyPluginApiRefEventMap> {
+    /**
+     * Whether the API can be used right now, and if not, why. Read at the moment of reading.
+     */
+    readonly availability: PluginAvailability;
+    /**
+     * The API, or `null` when it is not available right now. `null` during the consumer's `onload` may only
+     * mean the plugin has not loaded yet; the value becomes the API on its own once it has.
+     */
+    readonly value: null | TApi;
+}
+/**
+ * The events a {@link ThirdPartyPluginApiRef} fires.
+ */
+export interface ThirdPartyPluginApiRefEventMap {
+    /**
+     * Fired whenever {@link ThirdPartyPluginApiRef.value} changes, including when it becomes `null` because the
+     * plugin was disabled or reloaded.
+     */
+    readonly change: [];
+}
+/**
+ * A third-party plugin another plugin cannot work without, declared through
+ * `PluginBase.getPluginDependencies()`.
+ *
+ * Built by {@link createThirdPartyPluginDependency}, which copies the adapter's id and name.
+ */
+export interface ThirdPartyPluginDependency extends PluginDependencyBase {
+    /**
+     * The adapter the gate reads the dependency's API through.
+     */
+    readonly adapter: ThirdPartyPluginAdapter<object>;
+}
+/**
+ * Parameters for {@link waitForThirdPartyPluginApi}.
+ *
+ * @typeParam TApi - The adapter's API type.
+ */
+export interface WaitForThirdPartyPluginApiParams<TApi extends object> extends Except<WaitForPluginParams, 'app' | 'isPlugin' | 'minPluginVersion' | 'pluginId'>, GetThirdPartyPluginApiParams<TApi> {
+}
+/**
+ * Parameters for {@link watchThirdPartyPluginApi}.
+ *
+ * @typeParam TApi - The adapter's API type.
+ */
+export interface WatchThirdPartyPluginApiParams<TApi extends object> extends GetThirdPartyPluginApiParams<TApi> {
+    /**
+     * The component owning the watch. Its unload stops it.
+     */
+    readonly component: Component;
+}
+/**
+ * Builds the declaration of a required third-party plugin, for `PluginBase.getPluginDependencies()`.
+ *
+ * @typeParam TApi - The adapter's API type.
+ * @param params - The {@link CreateThirdPartyPluginDependencyParams}.
+ * @returns The dependency.
+ */
+export declare function createThirdPartyPluginDependency<TApi extends object>(params: CreateThirdPartyPluginDependencyParams<TApi>): ThirdPartyPluginDependency;
+/**
+ * Returns a third-party plugin's typed API when the plugin is {@link PluginAvailability.Available}, and `null`
+ * otherwise.
+ *
+ * @typeParam TApi - The adapter's API type.
+ * @param params - The {@link GetThirdPartyPluginApiParams}.
+ * @returns The API, or `null`.
+ */
+export declare function getThirdPartyPluginApi<TApi extends object>(params: GetThirdPartyPluginApiParams<TApi>): null | TApi;
+/**
+ * Reads whether a third-party plugin's API can be used right now, and if not, why.
+ *
+ * @typeParam TApi - The adapter's API type.
+ * @param params - The {@link GetThirdPartyPluginApiParams}.
+ * @returns The {@link PluginAvailability}; {@link PluginAvailability.ShapeMismatch} when the adapter does not
+ * recognize the running instance.
+ */
+export declare function getThirdPartyPluginAvailability<TApi extends object>(params: GetThirdPartyPluginAvailabilityParams<TApi>): PluginAvailability;
+/**
+ * Checks whether a dependency declared through `PluginBase.getPluginDependencies()` is a third-party one.
+ *
+ * @param dependency - The declared dependency.
+ * @returns Whether it carries an adapter.
+ */
+export declare function isThirdPartyPluginDependency(dependency: PluginDependencyBase): dependency is ThirdPartyPluginDependency;
+/**
+ * Waits for a third-party plugin's API, asking the user to install, enable or update the plugin while it is
+ * not available. Settles once; see `requirePlugin`.
+ *
+ * @typeParam TApi - The adapter's API type.
+ * @param params - The {@link RequireThirdPartyPluginApiParams}.
+ * @returns A {@link Promise} resolving with the API.
+ */
+export declare function requireThirdPartyPluginApi<TApi extends object>(params: RequireThirdPartyPluginApiParams<TApi>): Promise<TApi>;
+/**
+ * Waits for a third-party plugin's API to become available. Settles once; see `waitForPlugin`.
+ *
+ * @typeParam TApi - The adapter's API type.
+ * @param params - The {@link WaitForThirdPartyPluginApiParams}.
+ * @returns A {@link Promise} resolving with the API.
+ * @throws `PluginInstanceUnavailableError` when the timeout elapses.
+ */
+export declare function waitForThirdPartyPluginApi<TApi extends object>(params: WaitForThirdPartyPluginApiParams<TApi>): Promise<TApi>;
+/**
+ * Watches a third-party plugin's API and returns a live {@link ThirdPartyPluginApiRef}.
+ *
+ * The ref re-reads on every `app.plugins` `changed` and every library lifecycle broadcast, so it follows the
+ * plugin through enable, disable, update and reload with no polling. This is the shape of an OPTIONAL
+ * dependency: read `ref.value` where the integration is used, and treat `null` as "not there".
+ *
+ * @typeParam TApi - The adapter's API type.
+ * @param params - The {@link WatchThirdPartyPluginApiParams}.
+ * @returns The live reference.
+ */
+export declare function watchThirdPartyPluginApi<TApi extends object>(params: WatchThirdPartyPluginApiParams<TApi>): ThirdPartyPluginApiRef<TApi>;

package/dist/lib/esm/plugin/third-party-plugin.mjs

@@ -0,0 +1,147 @@
+/*
+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 ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { mixinAsyncEvents } from "@mnaoumov/typescript-lib/async-events";
+import {
+  getLoadedPlugin,
+  getPluginAvailability,
+  PluginAvailability,
+  PLUGINS_CHANGED_EVENT_NAME,
+  requirePlugin,
+  waitForPlugin
+} from "./plugin-instance.mjs";
+import {
+  PLUGIN_LOADED_EVENT_NAME,
+  PLUGIN_UNLOADED_EVENT_NAME
+} from "./plugin-lifecycle-events.mjs";
+class ThirdPartyPluginApiWatchBase {
+  // A `protected` constructor is not assignable to `AbstractConstructor<object>`, which is what
+  // `mixinAsyncEvents` accepts, so this stays public even though only the subclass below calls it.
+  constructor(params) {
+    this.params = params;
+  }
+  params;
+}
+class ThirdPartyPluginApiRefImpl extends mixinAsyncEvents()(ThirdPartyPluginApiWatchBase) {
+  get availability() {
+    return getThirdPartyPluginAvailability(this.params);
+  }
+  get value() {
+    return this.currentValue;
+  }
+  currentValue = null;
+  /**
+   * Re-reads the API, firing `change` only when it actually changed.
+   */
+  refresh() {
+    const value = getThirdPartyPluginApi(this.params);
+    if (value === this.currentValue) {
+      return;
+    }
+    this.currentValue = value;
+    this.trigger("change");
+  }
+}
+function createThirdPartyPluginDependency(params) {
+  const minPluginVersion = params.minPluginVersion ?? params.adapter.minPluginVersion;
+  return {
+    adapter: params.adapter,
+    pluginId: params.adapter.pluginId,
+    pluginName: params.adapter.pluginName,
+    reason: params.reason,
+    ...minPluginVersion !== void 0 && { minPluginVersion }
+  };
+}
+function getThirdPartyPluginApi(params) {
+  const plugin = getLoadedPlugin(toPluginAvailabilityParams(params));
+  return plugin === null ? null : params.adapter.getApi(plugin);
+}
+function getThirdPartyPluginAvailability(params) {
+  return getPluginAvailability(toPluginAvailabilityParams(params));
+}
+function isThirdPartyPluginDependency(dependency) {
+  return "adapter" in dependency;
+}
+async function requireThirdPartyPluginApi(params) {
+  const plugin = await requirePlugin({
+    ...params,
+    ...toPluginAvailabilityParams(params),
+    pluginName: params.adapter.pluginName
+  });
+  return getVerifiedApi(params.adapter, plugin);
+}
+async function waitForThirdPartyPluginApi(params) {
+  const plugin = await waitForPlugin({
+    ...params,
+    ...toPluginAvailabilityParams(params)
+  });
+  return getVerifiedApi(params.adapter, plugin);
+}
+function watchThirdPartyPluginApi(params) {
+  const { app, component } = params;
+  const ref = new ThirdPartyPluginApiRefImpl(params);
+  function refresh() {
+    ref.refresh();
+  }
+  component.registerEvent(app.plugins.on(PLUGINS_CHANGED_EVENT_NAME, refresh));
+  component.registerEvent(app.workspace.on(PLUGIN_LOADED_EVENT_NAME, refresh));
+  component.registerEvent(app.workspace.on(PLUGIN_UNLOADED_EVENT_NAME, refresh));
+  ref.refresh();
+  return ref;
+}
+function getVerifiedApi(adapter, plugin) {
+  const api = adapter.getApi(plugin);
+  if (api === null) {
+    throw new Error(`The plugin "${adapter.pluginId}" does not expose the API its adapter expects.`);
+  }
+  return api;
+}
+function toPluginAvailabilityParams(params) {
+  const { adapter, app } = params;
+  const minPluginVersion = params.minPluginVersion ?? adapter.minPluginVersion;
+  return {
+    app,
+    isPlugin: (plugin) => adapter.getApi(plugin) !== null,
+    pluginId: adapter.pluginId,
+    ...minPluginVersion !== void 0 && { minPluginVersion }
+  };
+}
+export {
+  createThirdPartyPluginDependency,
+  getThirdPartyPluginApi,
+  getThirdPartyPluginAvailability,
+  isThirdPartyPluginDependency,
+  requireThirdPartyPluginApi,
+  waitForThirdPartyPluginApi,
+  watchThirdPartyPluginApi
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/plugin/third-party-plugin.ts"],"sourcesContent":["/**\n * @file\n *\n * Typed access to the API of a THIRD-PARTY plugin: one that publishes nothing through this library's registry.\n *\n * A plugin built on this library publishes a versioned contract (`getPluginApis()`), and a consumer reaches it\n * through `watchPluginApi` (`./plugin-api.ts`). Most plugins a consumer wants to talk to — `Dataview`,\n * `Templater`, `Notebook Navigator` — are not built on it, so their API hangs off the plugin instance under a\n * name of their own choosing, and every consumer used to reach it by hand through `app.plugins` with a cast.\n *\n * A {@link ThirdPartyPluginAdapter} says ONCE, for one plugin, how to get from its instance to its typed API,\n * and VERIFIES the shape on the way, so a release that renamed what the adapter reads is \"not there\" rather\n * than a `Cannot read properties of undefined` from inside a callback. Everything else here is generic:\n *\n * - {@link getThirdPartyPluginApi} answers \"now\", for a one-shot use.\n * - {@link watchThirdPartyPluginApi} answers \"now\" for as long as a component lives: its ref re-reads on every\n *   `app.plugins` `changed` and every `obsidian-lib:plugin-loaded` / `-unloaded` broadcast, so an OPTIONAL\n *   dependency is a ref whose `value` is `null` while the plugin is absent, and becomes the API the moment it\n *   is enabled.\n * - {@link waitForThirdPartyPluginApi} and {@link requireThirdPartyPluginApi} are the one-shot waits, built on\n *   `waitForPlugin` / `requirePlugin` (`./plugin-instance.ts`), so they share that module's availability\n *   classification, its notice and its repair buttons.\n * - A REQUIRED dependency is declared through `PluginBase.getPluginDependencies()` as a\n *   {@link ThirdPartyPluginDependency} (built by {@link createThirdPartyPluginDependency}), and the plugin gate\n *   keeps `onloadImpl` from running while it is missing, too old or the wrong shape — the same treatment an\n *   own-plugin dependency gets.\n *\n * Availability is {@link PluginAvailability}, read from Obsidian `1.15.1` as `plugin-instance.ts` documents:\n * an instance whose `onload` is still running reads as `loading`, never as available. An adapter's\n * `getApi` returning `null` reads as {@link PluginAvailability.ShapeMismatch}.\n */\n\nimport type { AsyncEventSource } from '@mnaoumov/typescript-lib/async-events';\nimport type {\n  App,\n  Component,\n  Plugin\n} from 'obsidian';\nimport type { Except } from 'type-fest';\n\nimport { mixinAsyncEvents } from '@mnaoumov/typescript-lib/async-events';\n\nimport type { PluginDependencyBase } from '../components/plugin-gate-component.ts';\nimport type {\n  GetPluginAvailabilityParams,\n  RequirePluginParams,\n  WaitForPluginParams\n} from './plugin-instance.ts';\n\nimport {\n  getLoadedPlugin,\n  getPluginAvailability,\n  PluginAvailability,\n  PLUGINS_CHANGED_EVENT_NAME,\n  requirePlugin,\n  waitForPlugin\n} from './plugin-instance.ts';\nimport {\n  PLUGIN_LOADED_EVENT_NAME,\n  PLUGIN_UNLOADED_EVENT_NAME\n} from './plugin-lifecycle-events.ts';\n\n/**\n * Parameters for {@link createThirdPartyPluginDependency}.\n *\n * @typeParam TApi - The adapter's API type.\n */\nexport interface CreateThirdPartyPluginDependencyParams<TApi extends object> {\n  /**\n   * The adapter of the required plugin.\n   */\n  readonly adapter: ThirdPartyPluginAdapter<TApi>;\n\n  /**\n   * The oldest release the dependent works with. Defaults to the adapter's own\n   * {@link ThirdPartyPluginAdapter.minPluginVersion}; a dependent may only raise it.\n   */\n  readonly minPluginVersion?: string;\n\n  /**\n   * A localized sentence saying what the dependent does with the plugin, shown in the settings banner.\n   */\n  readonly reason: DocumentFragment | string;\n}\n\n/**\n * Parameters for {@link getThirdPartyPluginApi} and {@link getThirdPartyPluginAvailability}.\n *\n * @typeParam TApi - The adapter's API type.\n */\nexport interface GetThirdPartyPluginApiParams<TApi extends object> {\n  /**\n   * The adapter of the plugin.\n   */\n  readonly adapter: ThirdPartyPluginAdapter<TApi>;\n\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The oldest release the caller works with. Defaults to the adapter's own\n   * {@link ThirdPartyPluginAdapter.minPluginVersion}.\n   */\n  readonly minPluginVersion?: string;\n}\n\n/**\n * Parameters for {@link getThirdPartyPluginAvailability}.\n *\n * @typeParam TApi - The adapter's API type.\n */\nexport type GetThirdPartyPluginAvailabilityParams<TApi extends object> = GetThirdPartyPluginApiParams<TApi>;\n\n/**\n * Parameters for {@link requireThirdPartyPluginApi}.\n *\n * @typeParam TApi - The adapter's API type.\n */\nexport interface RequireThirdPartyPluginApiParams<TApi extends object> extends Except<RequirePluginParams, 'app' | 'isPlugin' | 'minPluginVersion' | 'pluginId' | 'pluginName'>, GetThirdPartyPluginApiParams<TApi> {}\n\n/**\n * How to get from one third-party plugin's instance to its typed API.\n *\n * An adapter is plain data plus one function, so it can be a module-level constant shared by every consumer,\n * and adding a plugin means adding one adapter.\n *\n * @typeParam TApi - The plugin's API, typed by the adapter's author and verified by {@link getApi}.\n */\nexport interface ThirdPartyPluginAdapter<TApi extends object> {\n  /**\n   * Reads the typed API off a running instance of the plugin, VERIFYING its shape.\n   *\n   * Return `null` when the instance does not carry the members the adapter types, which is what a release\n   * that renamed or reshaped them looks like. Never cast: a cast asserts a shape nothing checked.\n   *\n   * @param plugin - The running instance, whose `onload` has settled.\n   * @returns The API, or `null` when the instance is not the shape the adapter expects.\n   */\n  readonly getApi: (plugin: Plugin) => null | TApi;\n\n  /**\n   * The oldest release of the plugin the adapter was verified against, compared with its `manifest.version`.\n   * A release below it reads as {@link PluginAvailability.Outdated}.\n   */\n  readonly minPluginVersion?: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The display name of the plugin, shown to the user.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * A live reference to a third-party plugin's API.\n *\n * @typeParam TApi - The adapter's API type.\n */\nexport interface ThirdPartyPluginApiRef<TApi extends object> extends AsyncEventSource<ThirdPartyPluginApiRefEventMap> {\n  /**\n   * Whether the API can be used right now, and if not, why. Read at the moment of reading.\n   */\n  readonly availability: PluginAvailability;\n\n  /**\n   * The API, or `null` when it is not available right now. `null` during the consumer's `onload` may only\n   * mean the plugin has not loaded yet; the value becomes the API on its own once it has.\n   */\n  readonly value: null | TApi;\n}\n\n/**\n * The events a {@link ThirdPartyPluginApiRef} fires.\n */\nexport interface ThirdPartyPluginApiRefEventMap {\n  /**\n   * Fired whenever {@link ThirdPartyPluginApiRef.value} changes, including when it becomes `null` because the\n   * plugin was disabled or reloaded.\n   */\n  readonly change: [];\n}\n\n/**\n * A third-party plugin another plugin cannot work without, declared through\n * `PluginBase.getPluginDependencies()`.\n *\n * Built by {@link createThirdPartyPluginDependency}, which copies the adapter's id and name.\n */\nexport interface ThirdPartyPluginDependency extends PluginDependencyBase {\n  /**\n   * The adapter the gate reads the dependency's API through.\n   */\n  readonly adapter: ThirdPartyPluginAdapter<object>;\n}\n\n/**\n * Parameters for {@link waitForThirdPartyPluginApi}.\n *\n * @typeParam TApi - The adapter's API type.\n */\nexport interface WaitForThirdPartyPluginApiParams<TApi extends object> extends Except<WaitForPluginParams, 'app' | 'isPlugin' | 'minPluginVersion' | 'pluginId'>, GetThirdPartyPluginApiParams<TApi> {}\n\n/**\n * Parameters for {@link watchThirdPartyPluginApi}.\n *\n * @typeParam TApi - The adapter's API type.\n */\nexport interface WatchThirdPartyPluginApiParams<TApi extends object> extends GetThirdPartyPluginApiParams<TApi> {\n  /**\n   * The component owning the watch. Its unload stops it.\n   */\n  readonly component: Component;\n}\n\n/**\n * Holds the parameters, so the {@link mixinAsyncEvents} mixin has a real base to extend.\n */\nabstract class ThirdPartyPluginApiWatchBase {\n  // A `protected` constructor is not assignable to `AbstractConstructor<object>`, which is what\n  // `mixinAsyncEvents` accepts, so this stays public even though only the subclass below calls it.\n  public constructor(protected readonly params: GetThirdPartyPluginApiParams<object>) {}\n}\n\nclass ThirdPartyPluginApiRefImpl<TApi extends object> extends mixinAsyncEvents<ThirdPartyPluginApiRefEventMap>()(ThirdPartyPluginApiWatchBase) implements ThirdPartyPluginApiRef<TApi> {\n  public get availability(): PluginAvailability {\n    return getThirdPartyPluginAvailability(this.params);\n  }\n\n  public get value(): null | TApi {\n    return this.currentValue;\n  }\n\n  private currentValue: null | TApi = null;\n\n  /**\n   * Re-reads the API, firing `change` only when it actually changed.\n   */\n  public refresh(): void {\n    const value = getThirdPartyPluginApi(this.params) as null | TApi;\n    if (value === this.currentValue) {\n      return;\n    }\n\n    this.currentValue = value;\n    this.trigger('change');\n  }\n}\n\n/**\n * Builds the declaration of a required third-party plugin, for `PluginBase.getPluginDependencies()`.\n *\n * @typeParam TApi - The adapter's API type.\n * @param params - The {@link CreateThirdPartyPluginDependencyParams}.\n * @returns The dependency.\n */\nexport function createThirdPartyPluginDependency<TApi extends object>(params: CreateThirdPartyPluginDependencyParams<TApi>): ThirdPartyPluginDependency {\n  const minPluginVersion = params.minPluginVersion ?? params.adapter.minPluginVersion;\n  return {\n    adapter: params.adapter,\n    pluginId: params.adapter.pluginId,\n    pluginName: params.adapter.pluginName,\n    reason: params.reason,\n    ...(minPluginVersion !== undefined && { minPluginVersion })\n  };\n}\n\n/**\n * Returns a third-party plugin's typed API when the plugin is {@link PluginAvailability.Available}, and `null`\n * otherwise.\n *\n * @typeParam TApi - The adapter's API type.\n * @param params - The {@link GetThirdPartyPluginApiParams}.\n * @returns The API, or `null`.\n */\nexport function getThirdPartyPluginApi<TApi extends object>(params: GetThirdPartyPluginApiParams<TApi>): null | TApi {\n  const plugin = getLoadedPlugin(toPluginAvailabilityParams(params));\n  return plugin === null ? null : params.adapter.getApi(plugin);\n}\n\n/**\n * Reads whether a third-party plugin's API can be used right now, and if not, why.\n *\n * @typeParam TApi - The adapter's API type.\n * @param params - The {@link GetThirdPartyPluginApiParams}.\n * @returns The {@link PluginAvailability}; {@link PluginAvailability.ShapeMismatch} when the adapter does not\n * recognize the running instance.\n */\nexport function getThirdPartyPluginAvailability<TApi extends object>(params: GetThirdPartyPluginAvailabilityParams<TApi>): PluginAvailability {\n  return getPluginAvailability(toPluginAvailabilityParams(params));\n}\n\n/**\n * Checks whether a dependency declared through `PluginBase.getPluginDependencies()` is a third-party one.\n *\n * @param dependency - The declared dependency.\n * @returns Whether it carries an adapter.\n */\nexport function isThirdPartyPluginDependency(dependency: PluginDependencyBase): dependency is ThirdPartyPluginDependency {\n  return 'adapter' in dependency;\n}\n\n/**\n * Waits for a third-party plugin's API, asking the user to install, enable or update the plugin while it is\n * not available. Settles once; see `requirePlugin`.\n *\n * @typeParam TApi - The adapter's API type.\n * @param params - The {@link RequireThirdPartyPluginApiParams}.\n * @returns A {@link Promise} resolving with the API.\n */\nexport async function requireThirdPartyPluginApi<TApi extends object>(params: RequireThirdPartyPluginApiParams<TApi>): Promise<TApi> {\n  const plugin = await requirePlugin({\n    ...params,\n    ...toPluginAvailabilityParams(params),\n    pluginName: params.adapter.pluginName\n  });\n  return getVerifiedApi(params.adapter, plugin);\n}\n\n/**\n * Waits for a third-party plugin's API to become available. Settles once; see `waitForPlugin`.\n *\n * @typeParam TApi - The adapter's API type.\n * @param params - The {@link WaitForThirdPartyPluginApiParams}.\n * @returns A {@link Promise} resolving with the API.\n * @throws `PluginInstanceUnavailableError` when the timeout elapses.\n */\nexport async function waitForThirdPartyPluginApi<TApi extends object>(params: WaitForThirdPartyPluginApiParams<TApi>): Promise<TApi> {\n  const plugin = await waitForPlugin({\n    ...params,\n    ...toPluginAvailabilityParams(params)\n  });\n  return getVerifiedApi(params.adapter, plugin);\n}\n\n/**\n * Watches a third-party plugin's API and returns a live {@link ThirdPartyPluginApiRef}.\n *\n * The ref re-reads on every `app.plugins` `changed` and every library lifecycle broadcast, so it follows the\n * plugin through enable, disable, update and reload with no polling. This is the shape of an OPTIONAL\n * dependency: read `ref.value` where the integration is used, and treat `null` as \"not there\".\n *\n * @typeParam TApi - The adapter's API type.\n * @param params - The {@link WatchThirdPartyPluginApiParams}.\n * @returns The live reference.\n */\nexport function watchThirdPartyPluginApi<TApi extends object>(params: WatchThirdPartyPluginApiParams<TApi>): ThirdPartyPluginApiRef<TApi> {\n  const { app, component } = params;\n  const ref = new ThirdPartyPluginApiRefImpl<TApi>(params);\n  function refresh(): void {\n    ref.refresh();\n  }\n  component.registerEvent(app.plugins.on(PLUGINS_CHANGED_EVENT_NAME, refresh));\n  component.registerEvent(app.workspace.on(PLUGIN_LOADED_EVENT_NAME, refresh));\n  component.registerEvent(app.workspace.on(PLUGIN_UNLOADED_EVENT_NAME, refresh));\n  ref.refresh();\n  return ref;\n}\n\nfunction getVerifiedApi<TApi extends object>(adapter: ThirdPartyPluginAdapter<TApi>, plugin: Plugin): TApi {\n  const api = adapter.getApi(plugin);\n  if (api === null) {\n    // Unreachable through the waits, whose availability check already ran `getApi`; kept so a wrong adapter\n    // fails here by name rather than handing back `null` typed as the API.\n    throw new Error(`The plugin \"${adapter.pluginId}\" does not expose the API its adapter expects.`);\n  }\n\n  return api;\n}\n\nfunction toPluginAvailabilityParams<TApi extends object>(params: GetThirdPartyPluginApiParams<TApi>): GetPluginAvailabilityParams {\n  const { adapter, app } = params;\n  const minPluginVersion = params.minPluginVersion ?? adapter.minPluginVersion;\n  return {\n    app,\n    isPlugin: (plugin: Plugin): plugin is Plugin => adapter.getApi(plugin) !== null,\n    pluginId: adapter.pluginId,\n    ...(minPluginVersion !== undefined && { minPluginVersion })\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/release-asset.mjs

@@ -184,4 +184,4 @@ export {
   formatByteSize,
   getGitHubReleaseAssetUrl
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/release-asset.ts"],"sourcesContent":["/**\n * @file\n *\n * Downloads an optional data asset of a plugin release on demand: it asks the user first, verifies an expected SHA-256\n * before anything is written or exposed, keeps the verified file in a local cache folder and hands back the adapter\n * resource URL.\n *\n * It uses only cross-platform APIs ({@link requestUrlEx}, the vault adapter and `crypto.subtle`), so it works on desktop\n * and mobile alike.\n *\n * Behavior that is part of the contract:\n *\n * - A cached file is hashed on every call. When its hash matches, it is reused without asking or downloading. When it\n *   does not, it is removed and treated as missing, so a corrupt or truncated cache recovers by itself.\n * - The user is asked only when a download is needed. Declining resolves with `null` and writes nothing.\n * - Downloaded bytes are verified before they are written. A mismatch throws {@link ReleaseAssetChecksumError} and\n *   writes nothing.\n * - The file is written to a temporary sibling and then renamed into place, so an interrupted write never leaves a\n *   partial file under the cached name.\n * - An abort (pass the plugin's abort signal, so a plugin unload counts) rejects with the signal's reason. Once the\n *   download has finished, the signal is checked again before writing, so nothing is written after an unload.\n * - Concurrent calls for the same cache path share one operation, so the user is asked once.\n */\n\nimport type { App } from 'obsidian';\n\nimport { join } from '@mnaoumov/typescript-lib/path';\n\nimport { t } from './i18n/i18n.ts';\nimport { confirm } from './modals/confirm.ts';\nimport { requestUrlEx } from './request-url.ts';\n\nconst BYTES_IN_KILOBYTE = 1024;\nconst HEX_BYTE_LENGTH = 2;\nconst HEX_RADIX = 16;\nconst SHA_256_HEX_REG_EXP = /^[0-9a-f]{64}$/i;\nconst TEMPORARY_FILE_SUFFIX = '.download';\n\n/**\n * Parameters for {@link ensureReleaseAsset}.\n */\nexport interface EnsureReleaseAssetParams {\n  /**\n   * Aborts the operation. Pass the plugin's abort signal, so an unload stops it.\n   */\n  readonly abortSignal?: AbortSignal | undefined;\n\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The vault-relative folder that holds the cached file, typically `${plugin.manifest.dir}/assets`.\n   *\n   * A folder inside the config folder is not synced, so each device downloads the asset once.\n   */\n  readonly cacheFolderPath: string;\n\n  /**\n   * The name of the cached file. It must not contain a path separator.\n   */\n  readonly fileName: string;\n\n  /**\n   * The expected SHA-256 of the asset, as 64 hexadecimal digits.\n   */\n  readonly sha256: string;\n\n  /**\n   * Asks the user whether to download the asset. Defaults to a confirmation modal.\n   *\n   * Pass `() => Promise.resolve(true)` when the user has already agreed, for example through a setting.\n   */\n  readonly shouldDownload?: ((request: ReleaseAssetConsentRequest) => Promise<boolean>) | undefined;\n\n  /**\n   * The size of the asset in bytes, shown to the user when asking.\n   */\n  readonly sizeInBytes?: number | undefined;\n\n  /**\n   * The download timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n\n  /**\n   * The URL to download the asset from. Only `http:` and `https:` URLs are accepted.\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link getGitHubReleaseAssetUrl}.\n */\nexport interface GetGitHubReleaseAssetUrlParams {\n  /**\n   * The name of the release asset.\n   */\n  readonly fileName: string;\n\n  /**\n   * The repository, as `<owner>/<name>`.\n   */\n  readonly repository: string;\n\n  /**\n   * The release tag, typically the plugin version.\n   */\n  readonly tag: string;\n}\n\n/**\n * A verified release asset.\n */\nexport interface ReleaseAsset {\n  /**\n   * The vault-relative path of the cached file.\n   */\n  readonly path: string;\n\n  /**\n   * The resource URL of the cached file, from the adapter's `getResourcePath`.\n   */\n  readonly resourceUrl: string;\n\n  /**\n   * Whether the file was already cached, so nothing was downloaded.\n   */\n  readonly wasCached: boolean;\n}\n\n/**\n * Parameters for {@link ReleaseAssetChecksumError}.\n */\nexport interface ReleaseAssetChecksumErrorConstructorParams {\n  /**\n   * The SHA-256 of the downloaded bytes.\n   */\n  readonly actualSha256: string;\n\n  /**\n   * The expected SHA-256.\n   */\n  readonly expectedSha256: string;\n\n  /**\n   * The URL the asset was downloaded from.\n   */\n  readonly url: string;\n}\n\n/**\n * What the user is asked to agree to.\n */\nexport interface ReleaseAssetConsentRequest {\n  /**\n   * The name of the asset.\n   */\n  readonly fileName: string;\n\n  /**\n   * The size of the asset in bytes, when known.\n   */\n  readonly sizeInBytes?: number | undefined;\n\n  /**\n   * The URL the asset is downloaded from.\n   */\n  readonly url: string;\n}\n\n/**\n * Thrown when downloaded bytes do not match the expected SHA-256. Nothing was written.\n */\nexport class ReleaseAssetChecksumError extends Error {\n  /**\n   * The SHA-256 of the downloaded bytes.\n   */\n  public readonly actualSha256: string;\n\n  /**\n   * The expected SHA-256.\n   */\n  public readonly expectedSha256: string;\n\n  /**\n   * The URL the asset was downloaded from.\n   */\n  public readonly url: string;\n\n  /**\n   * Creates the error.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: ReleaseAssetChecksumErrorConstructorParams) {\n    super(`The asset downloaded from ${params.url} has SHA-256 ${params.actualSha256}, expected ${params.expectedSha256}.`);\n    this.name = 'ReleaseAssetChecksumError';\n    this.actualSha256 = params.actualSha256;\n    this.expectedSha256 = params.expectedSha256;\n    this.url = params.url;\n  }\n}\n\nconst inFlightOperations = new Map<string, Promise<null | ReleaseAsset>>();\n\n/**\n * Computes the SHA-256 of the given bytes.\n *\n * @param data - The bytes.\n * @returns The SHA-256 as 64 lowercase hexadecimal digits.\n */\nexport async function computeSha256(data: ArrayBuffer): Promise<string> {\n  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- This is the Obsidian renderer Web API, not a Node builtin.\n  const hash = await window.crypto.subtle.digest('SHA-256', data);\n  return [...new Uint8Array(hash)].map((byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_LENGTH, '0')).join('');\n}\n\n/**\n * Returns the cached, verified asset, downloading it first, with the user's consent, when it is missing or corrupt.\n *\n * @param params - The parameters.\n * @returns The verified asset, or `null` when the user declined the download.\n */\nexport async function ensureReleaseAsset(params: EnsureReleaseAssetParams): Promise<null | ReleaseAsset> {\n  if (!SHA_256_HEX_REG_EXP.test(params.sha256)) {\n    throw new Error(`Invalid SHA-256: ${params.sha256}`);\n  }\n\n  if (!params.fileName || /[/\\\\]/.test(params.fileName) || params.fileName === '.' || params.fileName === '..') {\n    throw new Error(`Invalid asset file name: ${params.fileName}`);\n  }\n\n  const path = join(params.cacheFolderPath, params.fileName);\n  const inFlightOperation = inFlightOperations.get(path);\n  if (inFlightOperation) {\n    return await inFlightOperation;\n  }\n\n  const operation = ensureReleaseAssetImpl(params, path);\n  inFlightOperations.set(path, operation);\n  try {\n    return await operation;\n  } finally {\n    inFlightOperations.delete(path);\n  }\n}\n\n/**\n * Formats a byte size for a person to read.\n *\n * @param sizeInBytes - The size in bytes.\n * @returns The formatted size, such as `12.3 MB`.\n */\nexport function formatByteSize(sizeInBytes: number): string {\n  if (sizeInBytes < BYTES_IN_KILOBYTE) {\n    return `${String(sizeInBytes)} B`;\n  }\n  let size = sizeInBytes / BYTES_IN_KILOBYTE;\n  let unit = 'KB';\n  for (const largerUnit of ['MB', 'GB']) {\n    if (size < BYTES_IN_KILOBYTE) {\n      break;\n    }\n    size /= BYTES_IN_KILOBYTE;\n    unit = largerUnit;\n  }\n  return `${size.toFixed(1)} ${unit}`;\n}\n\n/**\n * Builds the download URL of a GitHub release asset.\n *\n * @param params - The parameters.\n * @returns The URL.\n */\nexport function getGitHubReleaseAssetUrl(params: GetGitHubReleaseAssetUrlParams): string {\n  return `https://github.com/${params.repository}/releases/download/${encodeURIComponent(params.tag)}/${encodeURIComponent(params.fileName)}`;\n}\n\nasync function ensureReleaseAssetImpl(params: EnsureReleaseAssetParams, path: string): Promise<null | ReleaseAsset> {\n  const { abortSignal, app } = params;\n  const adapter = app.vault.adapter;\n  const expectedSha256 = params.sha256.toLowerCase();\n  abortSignal?.throwIfAborted();\n\n  if (await adapter.exists(path)) {\n    const cachedBytes = await adapter.readBinary(path);\n    if (await computeSha256(cachedBytes) === expectedSha256) {\n      return {\n        path,\n        resourceUrl: adapter.getResourcePath(path),\n        wasCached: true\n      };\n    }\n    await adapter.remove(path);\n  }\n\n  const consentRequest: ReleaseAssetConsentRequest = {\n    fileName: params.fileName,\n    sizeInBytes: params.sizeInBytes,\n    url: params.url\n  };\n  const isDownloadAllowed = params.shouldDownload ? await params.shouldDownload(consentRequest) : await shouldDownloadWithModal(app, consentRequest);\n  if (!isDownloadAllowed) {\n    return null;\n  }\n  abortSignal?.throwIfAborted();\n\n  const response = await requestUrlEx({\n    abortSignal,\n    timeoutInMilliseconds: params.timeoutInMilliseconds,\n    url: params.url\n  });\n  const bytes = response.arrayBuffer;\n  const actualSha256 = await computeSha256(bytes);\n  if (actualSha256 !== expectedSha256) {\n    throw new ReleaseAssetChecksumError({ actualSha256, expectedSha256, url: params.url });\n  }\n  abortSignal?.throwIfAborted();\n\n  if (!await adapter.exists(params.cacheFolderPath)) {\n    await adapter.mkdir(params.cacheFolderPath);\n  }\n\n  const temporaryPath = `${path}${TEMPORARY_FILE_SUFFIX}`;\n  try {\n    await adapter.writeBinary(temporaryPath, bytes);\n    if (await adapter.exists(path)) {\n      await adapter.remove(path);\n    }\n    await adapter.rename(temporaryPath, path);\n  } catch (error) {\n    if (await adapter.exists(temporaryPath)) {\n      await adapter.remove(temporaryPath);\n    }\n    throw error;\n  }\n\n  return {\n    path,\n    resourceUrl: adapter.getResourcePath(path),\n    wasCached: false\n  };\n}\n\nasync function shouldDownloadWithModal(app: App, request: ReleaseAssetConsentRequest): Promise<boolean> {\n  const host = new URL(request.url).host;\n  const message = request.sizeInBytes === undefined\n    ? t(($) => $.obsidianLib.releaseAsset.consentMessageUnknownSize, { fileName: request.fileName, host })\n    : t(($) => $.obsidianLib.releaseAsset.consentMessage, { fileName: request.fileName, host, size: formatByteSize(request.sizeInBytes) });\n  return await confirm({\n    app,\n    message,\n    okButtonText: t(($) => $.obsidianLib.releaseAsset.download),\n    title: t(($) => $.obsidianLib.releaseAsset.consentTitle, { fileName: request.fileName })\n  });\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/release-asset.ts"],"sourcesContent":["/**\n * @file\n *\n * Downloads an optional data asset of a plugin release on demand: it asks the user first, verifies an expected SHA-256\n * before anything is written or exposed, keeps the verified file in a local cache folder and hands back the adapter\n * resource URL.\n *\n * It uses only cross-platform APIs ({@link requestUrlEx}, the vault adapter and `crypto.subtle`), so it works on desktop\n * and mobile alike.\n *\n * Behavior that is part of the contract:\n *\n * - A cached file is hashed on every call. When its hash matches, it is reused without asking or downloading. When it\n *   does not, it is removed and treated as missing, so a corrupt or truncated cache recovers by itself.\n * - The user is asked only when a download is needed. Declining resolves with `null` and writes nothing.\n * - Downloaded bytes are verified before they are written. A mismatch throws {@link ReleaseAssetChecksumError} and\n *   writes nothing.\n * - The file is written to a temporary sibling and then renamed into place, so an interrupted write never leaves a\n *   partial file under the cached name.\n * - An abort (pass the plugin's abort signal, so a plugin unload counts) rejects with the signal's reason. Once the\n *   download has finished, the signal is checked again before writing, so nothing is written after an unload.\n * - Concurrent calls for the same cache path share one operation, so the user is asked once.\n */\n\nimport type { App } from 'obsidian';\n\nimport { join } from '@mnaoumov/typescript-lib/path';\n\nimport { t } from './i18n/i18n.ts';\nimport { confirm } from './modals/confirm.ts';\nimport { requestUrlEx } from './request-url.ts';\n\nconst BYTES_IN_KILOBYTE = 1024;\nconst HEX_BYTE_LENGTH = 2;\nconst HEX_RADIX = 16;\nconst SHA_256_HEX_REG_EXP = /^[0-9a-f]{64}$/i;\nconst TEMPORARY_FILE_SUFFIX = '.download';\n\n/**\n * Parameters for {@link ensureReleaseAsset}.\n */\nexport interface EnsureReleaseAssetParams {\n  /**\n   * Aborts the operation. Pass the plugin's abort signal, so an unload stops it.\n   */\n  readonly abortSignal?: AbortSignal | undefined;\n\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The vault-relative folder that holds the cached file, typically `${plugin.manifest.dir}/assets`.\n   *\n   * A folder inside the config folder is not synced, so each device downloads the asset once.\n   */\n  readonly cacheFolderPath: string;\n\n  /**\n   * The name of the cached file. It must not contain a path separator.\n   */\n  readonly fileName: string;\n\n  /**\n   * The expected SHA-256 of the asset, as 64 hexadecimal digits.\n   */\n  readonly sha256: string;\n\n  /**\n   * Asks the user whether to download the asset. Defaults to a confirmation modal.\n   *\n   * Pass `() => Promise.resolve(true)` when the user has already agreed, for example through a setting.\n   */\n  readonly shouldDownload?: ((request: ReleaseAssetConsentRequest) => Promise<boolean>) | undefined;\n\n  /**\n   * The size of the asset in bytes, shown to the user when asking.\n   */\n  readonly sizeInBytes?: number | undefined;\n\n  /**\n   * The download timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n\n  /**\n   * The URL to download the asset from. Only `http:` and `https:` URLs are accepted.\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link getGitHubReleaseAssetUrl}.\n */\nexport interface GetGitHubReleaseAssetUrlParams {\n  /**\n   * The name of the release asset.\n   */\n  readonly fileName: string;\n\n  /**\n   * The repository, as `<owner>/<name>`.\n   */\n  readonly repository: string;\n\n  /**\n   * The release tag, typically the plugin version.\n   */\n  readonly tag: string;\n}\n\n/**\n * A verified release asset.\n */\nexport interface ReleaseAsset {\n  /**\n   * The vault-relative path of the cached file.\n   */\n  readonly path: string;\n\n  /**\n   * The resource URL of the cached file, from the adapter's `getResourcePath`.\n   */\n  readonly resourceUrl: string;\n\n  /**\n   * Whether the file was already cached, so nothing was downloaded.\n   */\n  readonly wasCached: boolean;\n}\n\n/**\n * Parameters for {@link ReleaseAssetChecksumError}.\n */\nexport interface ReleaseAssetChecksumErrorConstructorParams {\n  /**\n   * The SHA-256 of the downloaded bytes.\n   */\n  readonly actualSha256: string;\n\n  /**\n   * The expected SHA-256.\n   */\n  readonly expectedSha256: string;\n\n  /**\n   * The URL the asset was downloaded from.\n   */\n  readonly url: string;\n}\n\n/**\n * What the user is asked to agree to.\n */\nexport interface ReleaseAssetConsentRequest {\n  /**\n   * The name of the asset.\n   */\n  readonly fileName: string;\n\n  /**\n   * The size of the asset in bytes, when known.\n   */\n  readonly sizeInBytes?: number | undefined;\n\n  /**\n   * The URL the asset is downloaded from.\n   */\n  readonly url: string;\n}\n\n/**\n * Thrown when downloaded bytes do not match the expected SHA-256. Nothing was written.\n */\nexport class ReleaseAssetChecksumError extends Error {\n  /**\n   * The SHA-256 of the downloaded bytes.\n   */\n  public readonly actualSha256: string;\n\n  /**\n   * The expected SHA-256.\n   */\n  public readonly expectedSha256: string;\n\n  /**\n   * The URL the asset was downloaded from.\n   */\n  public readonly url: string;\n\n  /**\n   * Creates the error.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: ReleaseAssetChecksumErrorConstructorParams) {\n    super(`The asset downloaded from ${params.url} has SHA-256 ${params.actualSha256}, expected ${params.expectedSha256}.`);\n    this.name = 'ReleaseAssetChecksumError';\n    this.actualSha256 = params.actualSha256;\n    this.expectedSha256 = params.expectedSha256;\n    this.url = params.url;\n  }\n}\n\nconst inFlightOperations = new Map<string, Promise<null | ReleaseAsset>>();\n\n/**\n * Computes the SHA-256 of the given bytes.\n *\n * @param data - The bytes.\n * @returns The SHA-256 as 64 lowercase hexadecimal digits.\n */\nexport async function computeSha256(data: ArrayBuffer): Promise<string> {\n  const hash = await window.crypto.subtle.digest('SHA-256', data);\n  return [...new Uint8Array(hash)].map((byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_LENGTH, '0')).join('');\n}\n\n/**\n * Returns the cached, verified asset, downloading it first, with the user's consent, when it is missing or corrupt.\n *\n * @param params - The parameters.\n * @returns The verified asset, or `null` when the user declined the download.\n */\nexport async function ensureReleaseAsset(params: EnsureReleaseAssetParams): Promise<null | ReleaseAsset> {\n  if (!SHA_256_HEX_REG_EXP.test(params.sha256)) {\n    throw new Error(`Invalid SHA-256: ${params.sha256}`);\n  }\n\n  if (!params.fileName || /[/\\\\]/.test(params.fileName) || params.fileName === '.' || params.fileName === '..') {\n    throw new Error(`Invalid asset file name: ${params.fileName}`);\n  }\n\n  const path = join(params.cacheFolderPath, params.fileName);\n  const inFlightOperation = inFlightOperations.get(path);\n  if (inFlightOperation) {\n    return await inFlightOperation;\n  }\n\n  const operation = ensureReleaseAssetImpl(params, path);\n  inFlightOperations.set(path, operation);\n  try {\n    return await operation;\n  } finally {\n    inFlightOperations.delete(path);\n  }\n}\n\n/**\n * Formats a byte size for a person to read.\n *\n * @param sizeInBytes - The size in bytes.\n * @returns The formatted size, such as `12.3 MB`.\n */\nexport function formatByteSize(sizeInBytes: number): string {\n  if (sizeInBytes < BYTES_IN_KILOBYTE) {\n    return `${String(sizeInBytes)} B`;\n  }\n  let size = sizeInBytes / BYTES_IN_KILOBYTE;\n  let unit = 'KB';\n  for (const largerUnit of ['MB', 'GB']) {\n    if (size < BYTES_IN_KILOBYTE) {\n      break;\n    }\n    size /= BYTES_IN_KILOBYTE;\n    unit = largerUnit;\n  }\n  return `${size.toFixed(1)} ${unit}`;\n}\n\n/**\n * Builds the download URL of a GitHub release asset.\n *\n * @param params - The parameters.\n * @returns The URL.\n */\nexport function getGitHubReleaseAssetUrl(params: GetGitHubReleaseAssetUrlParams): string {\n  return `https://github.com/${params.repository}/releases/download/${encodeURIComponent(params.tag)}/${encodeURIComponent(params.fileName)}`;\n}\n\nasync function ensureReleaseAssetImpl(params: EnsureReleaseAssetParams, path: string): Promise<null | ReleaseAsset> {\n  const { abortSignal, app } = params;\n  const adapter = app.vault.adapter;\n  const expectedSha256 = params.sha256.toLowerCase();\n  abortSignal?.throwIfAborted();\n\n  if (await adapter.exists(path)) {\n    const cachedBytes = await adapter.readBinary(path);\n    if (await computeSha256(cachedBytes) === expectedSha256) {\n      return {\n        path,\n        resourceUrl: adapter.getResourcePath(path),\n        wasCached: true\n      };\n    }\n    await adapter.remove(path);\n  }\n\n  const consentRequest: ReleaseAssetConsentRequest = {\n    fileName: params.fileName,\n    sizeInBytes: params.sizeInBytes,\n    url: params.url\n  };\n  const isDownloadAllowed = params.shouldDownload ? await params.shouldDownload(consentRequest) : await shouldDownloadWithModal(app, consentRequest);\n  if (!isDownloadAllowed) {\n    return null;\n  }\n  abortSignal?.throwIfAborted();\n\n  const response = await requestUrlEx({\n    abortSignal,\n    timeoutInMilliseconds: params.timeoutInMilliseconds,\n    url: params.url\n  });\n  const bytes = response.arrayBuffer;\n  const actualSha256 = await computeSha256(bytes);\n  if (actualSha256 !== expectedSha256) {\n    throw new ReleaseAssetChecksumError({ actualSha256, expectedSha256, url: params.url });\n  }\n  abortSignal?.throwIfAborted();\n\n  if (!await adapter.exists(params.cacheFolderPath)) {\n    await adapter.mkdir(params.cacheFolderPath);\n  }\n\n  const temporaryPath = `${path}${TEMPORARY_FILE_SUFFIX}`;\n  try {\n    await adapter.writeBinary(temporaryPath, bytes);\n    if (await adapter.exists(path)) {\n      await adapter.remove(path);\n    }\n    await adapter.rename(temporaryPath, path);\n  } catch (error) {\n    if (await adapter.exists(temporaryPath)) {\n      await adapter.remove(temporaryPath);\n    }\n    throw error;\n  }\n\n  return {\n    path,\n    resourceUrl: adapter.getResourcePath(path),\n    wasCached: false\n  };\n}\n\nasync function shouldDownloadWithModal(app: App, request: ReleaseAssetConsentRequest): Promise<boolean> {\n  const host = new URL(request.url).host;\n  const message = request.sizeInBytes === undefined\n    ? t(($) => $.obsidianLib.releaseAsset.consentMessageUnknownSize, { fileName: request.fileName, host })\n    : t(($) => $.obsidianLib.releaseAsset.consentMessage, { fileName: request.fileName, host, size: formatByteSize(request.sizeInBytes) });\n  return await confirm({\n    app,\n    message,\n    okButtonText: t(($) => $.obsidianLib.releaseAsset.download),\n    title: t(($) => $.obsidianLib.releaseAsset.consentTitle, { fileName: request.fileName })\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/resource-lock.d.mts

@@ -36,6 +36,7 @@
  *
  * The explicit {@link unlockResourceForPath} pair remains available for non-`using` call sites.
  */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';
 import type { App } from 'obsidian';
 import type { PathOrFile } from './file-system.mjs';
 import { ComponentEx } from './components/component-ex.mjs';
@@ -176,9 +177,9 @@ export declare class ResourceLockComponent extends ComponentEx {
      * ```
      *
      * @param pathsOrFiles - The paths (or files/folders) whose mutation by this operation is sanctioned.
-     * @returns A {@link Disposable} that ends the bypass scope when disposed.
+     * @returns A {@link DisposableEx} that ends the bypass scope when disposed.
      */
-    bypassBlockedMutations(pathsOrFiles: readonly PathOrFile[]): Disposable;
+    bypassBlockedMutations(pathsOrFiles: readonly PathOrFile[]): DisposableEx;
     /**
      * Checks whether the path is locked directly or lies under a `subtree`-locked ancestor folder.
      *
@@ -212,9 +213,9 @@ export declare class ResourceLockComponent extends ComponentEx {
      * in the unlock confirmation). Pass an {@link ResourceLockComponentLockForPathParams.abortController}
      * to make the lock cancelable via a lock indicator's "unlock" menu, the "Unlock active note" command,
      * or {@link requestResourceUnlockForPath}.
-     * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+     * @returns A {@link DisposableEx} that releases this lock when disposed. Disposing more than once is a no-op.
      */
-    lockForPath(params: ResourceLockComponentLockForPathParams): Disposable;
+    lockForPath(params: ResourceLockComponentLockForPathParams): DisposableEx;
     /**
      * Releases every lock still held by this plugin when the component (and thus the plugin) unloads,
      * so no note is left stuck read-only by an operation that never completed.
@@ -297,13 +298,13 @@ export declare function isResourceLockedForPathByAncestor(app: App, pathOrFile:
  * that currently hold a lock on the note.
  *
  * The lock is reference-counted per calling plugin: each call must be balanced by exactly one
- * release (either disposing the returned {@link Disposable} — ideally via a `using` declaration — or
+ * release (either disposing the returned {@link DisposableEx} — ideally via a `using` declaration — or
  * a matching {@link unlockResourceForPath} call).
  *
  * @param params - The parameters for locking the note.
- * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+ * @returns A {@link DisposableEx} that releases this lock when disposed. Disposing more than once is a no-op.
  */
-export declare function lockResourceForPath(params: LockResourceForPathParams): Disposable;
+export declare function lockResourceForPath(params: LockResourceForPathParams): DisposableEx;
 /**
  * Requests an unlock of the note at the given path by aborting every {@link AbortController} that was
  * associated with a lock on it (via {@link ResourceLockComponent.lockForPath}'s