@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/cjs/plugin/plugin-instance.d.cts

@@ -0,0 +1,258 @@
+/// <reference path="../library-references.d.cts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Another plugin's INSTANCE: whether it is there, waiting for it, and asking the user to bring it in.
+ *
+ * This is the path for a plugin that publishes nothing through the library's registry, which is most of
+ * them. A provider that does publish is better reached through `watchPluginApi` (`./plugin-api.ts`): its
+ * reference is live, version-negotiated and revoked when the provider goes away, none of which a bare
+ * instance offers. And a plugin that must STOP running when another one goes away declares it through
+ * `PluginBase.getPluginDependencies()`, whose gate owns that teardown — {@link requirePlugin} is a one-shot
+ * wait, not a second dependency system.
+ *
+ * What "loaded" can and cannot mean, read from Obsidian `1.15.1`:
+ *
+ * - `Plugins.loadPlugin` stores the instance in `app.plugins.plugins` BEFORE it awaits `plugin.load()`, and
+ *   `Plugin.load` sets `_loaded` before it awaits `onload()`. So `app.plugins.getPlugin(id)` can return a
+ *   plugin whose `onload` is still running, and `_loaded` cannot tell the two apart.
+ *   `Plugins.enablePlugin` brackets the load with `loadingPluginId`, which is the one signal that does, so
+ *   an instance whose id is `loadingPluginId` reads as {@link PluginAvailability.Loading}.
+ * - `onload` having settled is the most anything can promise. A plugin that starts further work from
+ *   `onload` without awaiting it, or waits for layout-ready, is "loaded" before that work is done, and
+ *   Obsidian has no hook saying every plugin has finished initializing. A plugin built on this library
+ *   says more through the `obsidian-lib:plugin-loaded` broadcast, which follows its published APIs.
+ * - `app.plugins` is an `Events` source that triggers `changed`, debounced by one macrotask, after every
+ *   enable, disable, install, uninstall and manifest reload. That is what a wait subscribes to, so nothing
+ *   here polls. It fires after `enablePlugin` returned, when `loadingPluginId` is `null` again.
+ *
+ * A type argument alone is a caller's ASSERTION about the instance, not a check: nothing at runtime knows
+ * what `TPlugin` is. Pass `isPlugin` to have the shape verified; an instance failing it reads as
+ * {@link PluginAvailability.ShapeMismatch}, the usual sign of a release that renamed what the caller uses.
+ */
+import type { App, Plugin } from 'obsidian' with { 'resolution-mode': 'import' };
+import { Component } from 'obsidian';
+import type { PluginNoticeComponent } from '../components/plugin-notice-component.cjs';
+/**
+ * The event `app.plugins` triggers after every enable, disable, install, uninstall and manifest reload.
+ *
+ * Read from Obsidian `1.15.1`: `didChange` triggers it debounced by one macrotask, so several changes in one
+ * task arrive as one event, after `enablePlugin` / `disablePlugin` returned.
+ */
+export declare const PLUGINS_CHANGED_EVENT_NAME = "changed";
+/**
+ * Whether another plugin's instance can be used right now, and if not, why.
+ */
+export declare enum PluginAvailability {
+    /**
+     * Loaded, `onload` settled, and every declared requirement met.
+     */
+    Available = "available",
+    /**
+     * Running at a release whose `manifest.version` cannot be parsed, while the caller declared a
+     * {@link GetPluginAvailabilityParams.minPluginVersion}. Counts as unavailable, because failing closed is the
+     * safe direction.
+     */
+    InvalidVersion = "invalidVersion",
+    /**
+     * The instance exists but its `onload` has not settled yet.
+     */
+    Loading = "loading",
+    /**
+     * Installed but neither enabled nor running.
+     */
+    NotEnabled = "notEnabled",
+    /**
+     * Not installed in this vault.
+     */
+    NotInstalled = "notInstalled",
+    /**
+     * Installed and enabled in the configuration, but no instance is running. At startup that is a plugin
+     * Obsidian has not reached yet; later it is one that failed to load, or one switched off by a disable that
+     * does not touch the configuration.
+     */
+    NotLoaded = "notLoaded",
+    /**
+     * Running at a release older than the caller's {@link GetPluginAvailabilityParams.minPluginVersion}.
+     */
+    Outdated = "outdated",
+    /**
+     * Running, but the caller's {@link GetPluginAvailabilityParams.isPlugin} rejected the instance.
+     */
+    ShapeMismatch = "shapeMismatch"
+}
+/**
+ * Parameters for {@link getLoadedPlugin}.
+ *
+ * @typeParam TPlugin - The plugin type the caller expects.
+ */
+export type GetLoadedPluginParams<TPlugin extends Plugin = Plugin> = GetPluginAvailabilityParams<TPlugin>;
+/**
+ * Parameters for {@link getPluginAvailability}.
+ *
+ * @typeParam TPlugin - The plugin type the caller expects.
+ */
+export interface GetPluginAvailabilityParams<TPlugin extends Plugin = Plugin> {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Verifies that the running instance is the shape the caller uses. Without it, `TPlugin` is an
+     * assertion nothing checks.
+     *
+     * @param plugin - The running instance.
+     * @returns Whether the instance is a `TPlugin`.
+     */
+    readonly isPlugin?: (plugin: Plugin) => plugin is TPlugin;
+    /**
+     * The oldest release of the plugin the caller works with, compared with its `manifest.version`. This is
+     * a plugin RELEASE, never an API contract version: a provider publishing a versioned contract is reached
+     * through `watchPluginApi`'s `apiVersionRange` instead.
+     */
+    readonly minPluginVersion?: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Parameters for the {@link PluginInstanceUnavailableError} constructor.
+ */
+export interface PluginInstanceUnavailableErrorConstructorParams {
+    /**
+     * Why the plugin was unavailable when the wait gave up.
+     */
+    readonly availability: PluginAvailability;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Parameters for {@link requirePlugin}.
+ *
+ * @typeParam TPlugin - The plugin type the caller expects.
+ */
+export interface RequirePluginParams<TPlugin extends Plugin = Plugin> extends GetPluginAvailabilityParams<TPlugin> {
+    /**
+     * Ends the wait early; the promise rejects with the signal's reason.
+     */
+    readonly abortSignal?: AbortSignal;
+    /**
+     * The component owning the wait and its notice. Its unload ends both, rejecting the promise.
+     */
+    readonly component: Component;
+    /**
+     * The display name of the required plugin, shown to the user.
+     */
+    readonly pluginName: string;
+    /**
+     * The asking plugin's notice component, which shows what is missing and the button that fixes it.
+     */
+    readonly pluginNoticeComponent: PluginNoticeComponent;
+    /**
+     * The display name of the asking plugin, named in the notice.
+     */
+    readonly requestingPluginName: string;
+    /**
+     * How long to wait before giving up. By default the wait lasts until the user repairs the plugin, the
+     * {@link RequirePluginParams.abortSignal} aborts or the {@link RequirePluginParams.component} unloads.
+     */
+    readonly timeoutInMilliseconds?: number;
+}
+/**
+ * Parameters for {@link waitForPlugin}.
+ *
+ * @typeParam TPlugin - The plugin type the caller expects.
+ */
+export interface WaitForPluginParams<TPlugin extends Plugin = Plugin> extends GetPluginAvailabilityParams<TPlugin> {
+    /**
+     * Ends the wait early; the promise rejects with the signal's reason.
+     */
+    readonly abortSignal?: AbortSignal;
+    /**
+     * A component whose unload ends the wait, rejecting the promise. Pass the waiting plugin, or the
+     * component that will use the instance, so a wait never outlives its consumer.
+     */
+    readonly component?: Component;
+    /**
+     * How long to wait before rejecting with a {@link PluginInstanceUnavailableError}.
+     *
+     * @default 10000
+     */
+    readonly timeoutInMilliseconds?: number;
+}
+/**
+ * Thrown when a plugin did not become available before a wait gave up.
+ */
+export declare class PluginInstanceUnavailableError extends Error {
+    /**
+     * Why the plugin was unavailable when the wait gave up.
+     */
+    readonly availability: PluginAvailability;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * Creates an instance of {@link PluginInstanceUnavailableError}.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: PluginInstanceUnavailableErrorConstructorParams);
+}
+/**
+ * Returns another plugin's instance when it is {@link PluginAvailability.Available}, and `null` otherwise.
+ *
+ * Unlike `app.plugins.getPlugin`, it never returns an instance whose `onload` is still running.
+ *
+ * @typeParam TPlugin - The plugin type the caller expects; checked only through `isPlugin`.
+ * @param params - The {@link GetPluginAvailabilityParams}.
+ * @returns The instance, or `null`.
+ */
+export declare function getLoadedPlugin<TPlugin extends Plugin = Plugin>(params: GetLoadedPluginParams<NoInfer<TPlugin>>): null | TPlugin;
+/**
+ * Reads whether another plugin's instance can be used right now, and if not, why.
+ *
+ * @typeParam TPlugin - The plugin type the caller expects.
+ * @param params - The {@link GetPluginAvailabilityParams}.
+ * @returns The {@link PluginAvailability}.
+ */
+export declare function getPluginAvailability<TPlugin extends Plugin = Plugin>(params: GetPluginAvailabilityParams<NoInfer<TPlugin>>): PluginAvailability;
+/**
+ * Waits for another plugin to become {@link PluginAvailability.Available}, asking the user to repair it
+ * while it is not.
+ *
+ * Resolves at once when it already is. Otherwise, once the workspace layout is ready — before that, a
+ * plugin Obsidian has not loaded yet is indistinguishable from a missing one — a notice says what is wrong
+ * and offers the matching repair: install, enable, or update, plus a way to the community plugins list.
+ * The notice follows the state as it changes and goes away when the wait settles. A repair that fails is
+ * reported and leaves the wait running, so the user can try again or fix it by hand.
+ *
+ * The promise settles ONCE. It does not watch the plugin afterwards: a consumer that must stop when the
+ * plugin goes away declares a dependency through `PluginBase.getPluginDependencies()` instead.
+ *
+ * @typeParam TPlugin - The plugin type the caller expects; checked only through `isPlugin`.
+ * @param params - The {@link RequirePluginParams}.
+ * @returns A {@link Promise} resolving with the instance.
+ * @throws The abort reason, or an error naming the unloaded component, when the wait is ended early.
+ * @throws {@link PluginInstanceUnavailableError} When {@link RequirePluginParams.timeoutInMilliseconds} elapses.
+ */
+export declare function requirePlugin<TPlugin extends Plugin = Plugin>(params: RequirePluginParams<NoInfer<TPlugin>>): Promise<TPlugin>;
+/**
+ * Waits for another plugin to become {@link PluginAvailability.Available}.
+ *
+ * Resolves at once when it already is, which covers a consumer reloaded after its dependency. Otherwise it
+ * re-reads the state on every `app.plugins` `changed` and every `obsidian-lib:plugin-loaded` broadcast, so a
+ * plugin enabled, updated or reloaded later is picked up with no polling. It subscribes before its first
+ * read, so a change landing in between cannot be missed. Every listener and timer is removed when it settles.
+ *
+ * @typeParam TPlugin - The plugin type the caller expects; checked only through `isPlugin`.
+ * @param params - The {@link WaitForPluginParams}.
+ * @returns A {@link Promise} resolving with the instance.
+ * @throws The abort reason, or an error naming the unloaded component, when the wait is ended early.
+ * @throws {@link PluginInstanceUnavailableError} When the timeout elapses, carrying the availability at that moment.
+ */
+export declare function waitForPlugin<TPlugin extends Plugin = Plugin>(params: WaitForPluginParams<NoInfer<TPlugin>>): Promise<TPlugin>;

package/dist/lib/cjs/plugin/plugin-lifecycle-events.cjs

@@ -104,4 +104,4 @@ function triggerPluginLifecycleEvent(params) {
   PLUGIN_UNLOADED_EVENT_NAME,
   triggerPluginLifecycleEvent
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/plugin/plugin-lifecycle-events.ts"],"sourcesContent":["/**\n * @file\n *\n * The lifecycle broadcast every {@link PluginBase} makes: `obsidian-lib:plugin-loaded` when it has\n * finished loading and `obsidian-lib:plugin-unloaded` when it goes away.\n *\n * Obsidian gives a plugin no way to learn that ANOTHER plugin was enabled or disabled — there is no such\n * event on `app.plugins`, and a plugin's own `Events` source cannot help a listener that does not yet hold\n * the instance. So the broadcast goes through `app.workspace`, which is one object every plugin in the\n * vault can reach. Deliberately NOT the `globalThis.__obsidianLib` bag the rest of the library shares\n * its state through: a listener there needs its own copy of this library, and these events are meant to be\n * consumable by any plugin at all.\n *\n * The names are past tense because a broadcast states something that has already happened. `loaded` in\n * particular carries a guarantee: it is triggered only after every API the plugin declares has been\n * published, so a listener may call them immediately.\n *\n * Both the event names and {@link PluginLifecycleEventPayload} are a CROSS-VERSION CONTRACT. Copies of\n * this library at different versions publish and consume them side by side in one vault, so neither may\n * change incompatibly: plain data only, and new payload fields only ever added.\n *\n * That contract is also PUBLISHED, as of the `Plugin API protocol` guide: third-party plugins that will\n * never install this library are told to hardcode these strings and this payload shape. Publishing it\n * added no new constraint — the cross-copy one above already forbade every change an outsider could\n * notice.\n */\n\nimport type { App } from 'obsidian';\n\n/**\n * The name of either lifecycle event.\n */\nexport type PluginLifecycleEventName = typeof PLUGIN_LOADED_EVENT_NAME | typeof PLUGIN_UNLOADED_EVENT_NAME;\n\n/**\n * The payload of {@link PLUGIN_LOADED_EVENT_NAME} and {@link PLUGIN_UNLOADED_EVENT_NAME}.\n *\n * Plain data by design — no class instances and no types owned by this library — because it crosses\n * between independently bundled copies of it, and between plugins that do not use it at all.\n */\nexport interface PluginLifecycleEventPayload {\n  /**\n   * The contract versions the plugin published, empty when it publishes no API.\n   *\n   * An array rather than a single version because a provider may publish several contract versions side by\n   * side, so consumers pinned to an older range keep working across a breaking change.\n   *\n   * The API objects themselves are deliberately NOT here. A handle delivered by a one-shot event is a\n   * probe: it answers \"now\" and never says when \"now\" changed, and one that outlives the provider is\n   * exactly the stale handle the plugin-api registry's revocable handles exist to prevent. Reach the API\n   * through `watchPluginApi` instead, whose reference stays correct across unload and re-enable.\n   */\n  readonly apiVersions: readonly string[];\n\n  /**\n   * The ids of the plugins this one declares as mandatory dependencies, empty when it declares none.\n   *\n   * Present so the relationship can be read from the OTHER end: a provider has no way to ask who depends\n   * on it — the registry only answers consumer-to-provider — and \"which installed plugins need this one\"\n   * is what lets a provider's settings tab tell the user why it is in their vault at all.\n   */\n  readonly dependencyPluginIds: readonly string[];\n\n  /**\n   * The plugin's `manifest.id`.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The plugin's `manifest.name`, for display.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The plugin's `manifest.version`.\n   */\n  readonly pluginVersion: string;\n}\n\n/**\n * Parameters for {@link triggerPluginLifecycleEvent}.\n */\nexport interface TriggerPluginLifecycleEventParams {\n  /**\n   * The Obsidian app instance whose workspace carries the broadcast.\n   */\n  readonly app: App;\n\n  /**\n   * The event to trigger.\n   */\n  readonly name: PluginLifecycleEventName;\n\n  /**\n   * The payload describing the plugin.\n   */\n  readonly payload: PluginLifecycleEventPayload;\n}\n\n/**\n * Triggered once a plugin has finished loading AND published every API it declares, so a listener may call\n * those APIs immediately.\n *\n * Namespaced by the package name rather than by an abbreviation of it: the event is global to the vault\n * and aimed at plugin authors who have never heard of this library, so the prefix has to identify itself.\n */\nexport const PLUGIN_LOADED_EVENT_NAME = 'obsidian-lib:plugin-loaded';\n\n/**\n * Triggered as a plugin unloads — whether the user disabled it, uninstalled it, or Obsidian is shutting\n * down. Its APIs are revoked by the time a listener runs.\n */\nexport const PLUGIN_UNLOADED_EVENT_NAME = 'obsidian-lib:plugin-unloaded';\n\ndeclare module 'obsidian' {\n  interface Workspace {\n    /**\n     * Subscribes to a plugin finishing its load, or to one unloading.\n     *\n     * @param name - Should be {@link PLUGIN_LOADED_EVENT_NAME} or {@link PLUGIN_UNLOADED_EVENT_NAME}.\n     * @param callback - The callback receiving the plugin's payload.\n     * @param context - The context passed as `this` to the `callback` function.\n     * @returns The event reference.\n     */\n    /*\n     * An augmentation of an EXISTING overload set has to stay a method signature. A property member does not merge into\n     * `Workspace.on`'s overloads, and TypeScript says so nowhere near here: the declaration itself compiles, and every\n     * call site loses the signature instead — `on(PLUGIN_LOADED_EVENT_NAME, ...)` fails with \"the last overload gave the\n     * following error\". The rule reports this one without a fix for the same reason, so the disable below is the answer\n     * rather than a deferral.\n     */\n    // eslint-disable-next-line @typescript-eslint/method-signature-style -- A property member does not merge into an existing overload set. See above.\n    on(\n      name: PluginLifecycleEventName,\n      callback: (payload: PluginLifecycleEventPayload) => unknown,\n      context?: unknown\n    ): EventRef;\n  }\n}\n\n/**\n * Triggers one of the two lifecycle events on the app's workspace.\n *\n * A thin typed wrapper over `Workspace.trigger`, which accepts any event name and any arguments, so that the one\n * place a payload is constructed is checked against {@link PluginLifecycleEventPayload}.\n *\n * @param params - The {@link TriggerPluginLifecycleEventParams}.\n */\nexport function triggerPluginLifecycleEvent(params: TriggerPluginLifecycleEventParams): void {\n  const { app, name, payload } = params;\n  app.workspace.trigger(name, payload);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0GO,MAAM,2BAA2B;AAMjC,MAAM,6BAA6B;AAoCnC,SAAS,4BAA4B,QAAiD;AAC3F,QAAM,EAAE,KAAK,MAAM,QAAQ,IAAI;AAC/B,MAAI,UAAU,QAAQ,MAAM,OAAO;AACrC;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/plugin/plugin-lifecycle-events.ts"],"sourcesContent":["/**\n * @file\n *\n * The lifecycle broadcast every {@link PluginBase} makes: `obsidian-lib:plugin-loaded` when it has\n * finished loading and `obsidian-lib:plugin-unloaded` when it goes away.\n *\n * Obsidian does say that SOME plugin changed: read from Obsidian `1.15.1`, `app.plugins` triggers\n * `changed`, debounced by one macrotask, after every enable, disable, install, uninstall and manifest\n * reload, but it carries no payload: it does not say which plugin changed, nor that its APIs are published.\n * This broadcast names the plugin and comes after its APIs, so it is the signal for \"that plugin is ready\n * to call\", and `changed` the signal for \"re-read the manifests\". The broadcast goes through\n * `app.workspace`, which is one object every plugin in the vault can reach. Deliberately NOT the `globalThis.__obsidianLib` bag the rest of the library shares\n * its state through: a listener there needs its own copy of this library, and these events are meant to be\n * consumable by any plugin at all.\n *\n * The names are past tense because a broadcast states something that has already happened. `loaded` in\n * particular carries a guarantee: it is triggered only after every API the plugin declares has been\n * published, so a listener may call them immediately.\n *\n * Both the event names and {@link PluginLifecycleEventPayload} are a CROSS-VERSION CONTRACT. Copies of\n * this library at different versions publish and consume them side by side in one vault, so neither may\n * change incompatibly: plain data only, and new payload fields only ever added.\n *\n * That contract is also PUBLISHED, as of the `Plugin API protocol` guide: third-party plugins that will\n * never install this library are told to hardcode these strings and this payload shape. Publishing it\n * added no new constraint — the cross-copy one above already forbade every change an outsider could\n * notice.\n */\n\nimport type { App } from 'obsidian';\n\n/**\n * The name of either lifecycle event.\n */\nexport type PluginLifecycleEventName = typeof PLUGIN_LOADED_EVENT_NAME | typeof PLUGIN_UNLOADED_EVENT_NAME;\n\n/**\n * The payload of {@link PLUGIN_LOADED_EVENT_NAME} and {@link PLUGIN_UNLOADED_EVENT_NAME}.\n *\n * Plain data by design — no class instances and no types owned by this library — because it crosses\n * between independently bundled copies of it, and between plugins that do not use it at all.\n */\nexport interface PluginLifecycleEventPayload {\n  /**\n   * The contract versions the plugin published, empty when it publishes no API.\n   *\n   * An array rather than a single version because a provider may publish several contract versions side by\n   * side, so consumers pinned to an older range keep working across a breaking change.\n   *\n   * The API objects themselves are deliberately NOT here. A handle delivered by a one-shot event is a\n   * probe: it answers \"now\" and never says when \"now\" changed, and one that outlives the provider is\n   * exactly the stale handle the plugin-api registry's revocable handles exist to prevent. Reach the API\n   * through `watchPluginApi` instead, whose reference stays correct across unload and re-enable.\n   */\n  readonly apiVersions: readonly string[];\n\n  /**\n   * The ids of the plugins this one declares as mandatory dependencies, empty when it declares none.\n   *\n   * Present so the relationship can be read from the OTHER end: a provider has no way to ask who depends\n   * on it — the registry only answers consumer-to-provider — and \"which installed plugins need this one\"\n   * is what lets a provider's settings tab tell the user why it is in their vault at all.\n   */\n  readonly dependencyPluginIds: readonly string[];\n\n  /**\n   * The plugin's `manifest.id`.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The plugin's `manifest.name`, for display.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The plugin's `manifest.version`.\n   */\n  readonly pluginVersion: string;\n}\n\n/**\n * Parameters for {@link triggerPluginLifecycleEvent}.\n */\nexport interface TriggerPluginLifecycleEventParams {\n  /**\n   * The Obsidian app instance whose workspace carries the broadcast.\n   */\n  readonly app: App;\n\n  /**\n   * The event to trigger.\n   */\n  readonly name: PluginLifecycleEventName;\n\n  /**\n   * The payload describing the plugin.\n   */\n  readonly payload: PluginLifecycleEventPayload;\n}\n\n/**\n * Triggered once a plugin has finished loading AND published every API it declares, so a listener may call\n * those APIs immediately.\n *\n * Namespaced by the package name rather than by an abbreviation of it: the event is global to the vault\n * and aimed at plugin authors who have never heard of this library, so the prefix has to identify itself.\n */\nexport const PLUGIN_LOADED_EVENT_NAME = 'obsidian-lib:plugin-loaded';\n\n/**\n * Triggered as a plugin unloads — whether the user disabled it, uninstalled it, or Obsidian is shutting\n * down. Its APIs are revoked by the time a listener runs.\n */\nexport const PLUGIN_UNLOADED_EVENT_NAME = 'obsidian-lib:plugin-unloaded';\n\ndeclare module 'obsidian' {\n  interface Workspace {\n    /**\n     * Subscribes to a plugin finishing its load, or to one unloading.\n     *\n     * @param name - Should be {@link PLUGIN_LOADED_EVENT_NAME} or {@link PLUGIN_UNLOADED_EVENT_NAME}.\n     * @param callback - The callback receiving the plugin's payload.\n     * @param context - The context passed as `this` to the `callback` function.\n     * @returns The event reference.\n     */\n    /*\n     * An augmentation of an EXISTING overload set has to stay a method signature. A property member does not merge into\n     * `Workspace.on`'s overloads, and TypeScript says so nowhere near here: the declaration itself compiles, and every\n     * call site loses the signature instead — `on(PLUGIN_LOADED_EVENT_NAME, ...)` fails with \"the last overload gave the\n     * following error\". The rule reports this one without a fix for the same reason, so the disable below is the answer\n     * rather than a deferral.\n     */\n    // eslint-disable-next-line @typescript-eslint/method-signature-style -- A property member does not merge into an existing overload set. See above.\n    on(\n      name: PluginLifecycleEventName,\n      callback: (payload: PluginLifecycleEventPayload) => unknown,\n      context?: unknown\n    ): EventRef;\n  }\n}\n\n/**\n * Triggers one of the two lifecycle events on the app's workspace.\n *\n * A thin typed wrapper over `Workspace.trigger`, which accepts any event name and any arguments, so that the one\n * place a payload is constructed is checked against {@link PluginLifecycleEventPayload}.\n *\n * @param params - The {@link TriggerPluginLifecycleEventParams}.\n */\nexport function triggerPluginLifecycleEvent(params: TriggerPluginLifecycleEventParams): void {\n  const { app, name, payload } = params;\n  app.workspace.trigger(name, payload);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4GO,MAAM,2BAA2B;AAMjC,MAAM,6BAA6B;AAoCnC,SAAS,4BAA4B,QAAiD;AAC3F,QAAM,EAAE,KAAK,MAAM,QAAQ,IAAI;AAC/B,MAAI,UAAU,QAAQ,MAAM,OAAO;AACrC;","names":[]}

package/dist/lib/cjs/plugin/plugin-lifecycle-events.d.cts

@@ -5,10 +5,12 @@
  * The lifecycle broadcast every {@link PluginBase} makes: `obsidian-lib:plugin-loaded` when it has
  * finished loading and `obsidian-lib:plugin-unloaded` when it goes away.
  *
- * Obsidian gives a plugin no way to learn that ANOTHER plugin was enabled or disabled — there is no such
- * event on `app.plugins`, and a plugin's own `Events` source cannot help a listener that does not yet hold
- * the instance. So the broadcast goes through `app.workspace`, which is one object every plugin in the
- * vault can reach. Deliberately NOT the `globalThis.__obsidianLib` bag the rest of the library shares
+ * Obsidian does say that SOME plugin changed: read from Obsidian `1.15.1`, `app.plugins` triggers
+ * `changed`, debounced by one macrotask, after every enable, disable, install, uninstall and manifest
+ * reload, but it carries no payload: it does not say which plugin changed, nor that its APIs are published.
+ * This broadcast names the plugin and comes after its APIs, so it is the signal for "that plugin is ready
+ * to call", and `changed` the signal for "re-read the manifests". The broadcast goes through
+ * `app.workspace`, which is one object every plugin in the vault can reach. Deliberately NOT the `globalThis.__obsidianLib` bag the rest of the library shares
  * its state through: a listener there needs its own copy of this library, and these events are meant to be
  * consumable by any plugin at all.
  *

package/dist/lib/cjs/plugin/plugin-settings-tab.cjs

@@ -118,21 +118,21 @@ __export(plugin_settings_tab_exports, {
   SAVE_TO_FILE_CONTEXT: () => SAVE_TO_FILE_CONTEXT
 });
 module.exports = __toCommonJS(plugin_settings_tab_exports);
-var import_async = require('@mnaoumov/typescript-lib/async');
-var import_async_events = require('@mnaoumov/typescript-lib/async-events');
-var import_function = require('@mnaoumov/typescript-lib/function');
-var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
-var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
-var import_obsidian = require('obsidian');
-var import_async_events_component = require('../components/async-events-component.cjs');
-var import_component_ex = require('../components/component-ex.cjs');
-var import_css_class = require('../css-class.cjs');
-var import_setting_component_wrapper = require('../setting-components/setting-component-wrapper.cjs');
-var import_text_based_component = require('../setting-components/text-based-component.cjs');
-var import_validator_component = require('../setting-components/validator-component.cjs');
-var import_setting_ex = require('../setting-ex.cjs');
-var import_validation = require('../validation.cjs');
-var import_plugin_context = require('./plugin-context.cjs');
+var import_async = require("@mnaoumov/typescript-lib/async");
+var import_async_events = require("@mnaoumov/typescript-lib/async-events");
+var import_function = require("@mnaoumov/typescript-lib/function");
+var import_object_utils = require("@mnaoumov/typescript-lib/object-utils");
+var import_type_guards = require("@mnaoumov/typescript-lib/type-guards");
+var import_obsidian = require("obsidian");
+var import_async_events_component = require("../components/async-events-component.cjs");
+var import_component_ex = require("../components/component-ex.cjs");
+var import_css_class = require("../css-class.cjs");
+var import_setting_component_wrapper = require("../setting-components/setting-component-wrapper.cjs");
+var import_text_based_component = require("../setting-components/text-based-component.cjs");
+var import_validator_component = require("../setting-components/validator-component.cjs");
+var import_setting_ex = require("../setting-ex.cjs");
+var import_validation = require("../validation.cjs");
+var import_plugin_context = require("./plugin-context.cjs");
 const SAVE_TO_FILE_CONTEXT = "PluginSettingsTab";
 class PluginSettingsTabEventsComponent extends import_component_ex.ComponentEx {
   params;