@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

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

@@ -2,14 +2,59 @@
 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;
+}
 
-import { getBugReportIssueFormUrl } from "../bug-report.mjs";
+ensureBrowserProcess();
+})();
+
+import { Notice } from "obsidian";
+import {
+  buildBugReportIssueFormLink,
+  formatBugReportEnvironment,
+  getBugReportEnvironment,
+  getBugReportIssueFormUrl
+} from "../bug-report.mjs";
+import { t } from "../i18n/i18n.mjs";
+import { copyTextManually } from "../modals/copy-text-manually.mjs";
+import { reviewBugReportDiagnostics } from "../modals/review-bug-report-diagnostics.mjs";
 import { OpenGitHubCommandHandler } from "./open-git-hub-command-handler.mjs";
+const CLIPBOARD_NOTICE_DURATION_IN_MILLISECONDS = 15e3;
 class OpenBugReportCommandHandler extends OpenGitHubCommandHandler {
   /**
    * The Obsidian app instance.
    */
   app;
+  /**
+   * Gets the optional diagnostics the report can carry.
+   */
+  getDiagnostics;
+  /**
+   * The most characters the encoded link may have before the report moves to the clipboard.
+   */
+  maxUrlLength;
   /**
    * The id of the reporting plugin.
    */
@@ -27,10 +72,46 @@ class OpenBugReportCommandHandler extends OpenGitHubCommandHandler {
       name: "Report a bug"
     });
     this.app = params.app;
+    this.getDiagnostics = params.getDiagnostics;
+    this.maxUrlLength = params.maxUrlLength;
     this.pluginId = params.pluginId;
   }
   /**
-   * Builds the prefilled bug-report URL.
+   * Lets the user review the diagnostics, if any, then opens the issue form. When the report is too long
+   * for a link, it is copied to the clipboard first, or shown for copying by hand when the clipboard
+   * refuses it.
+   */
+  async execute() {
+    if (!this.canExecute()) {
+      return;
+    }
+    const environment = await getBugReportEnvironment({ app: this.app, pluginId: this.pluginId });
+    const sections = await this.getDiagnostics?.() ?? [];
+    let diagnostics = [];
+    if (sections.length > 0) {
+      const reviewedSections = await reviewBugReportDiagnostics({
+        alwaysIncludedText: formatBugReportEnvironment(environment),
+        app: this.app,
+        sections
+      });
+      if (reviewedSections === null) {
+        return;
+      }
+      diagnostics = reviewedSections;
+    }
+    const link = buildBugReportIssueFormLink({
+      diagnostics,
+      environment,
+      gitHubRepo: this.gitHubRepo,
+      ...this.maxUrlLength !== void 0 && { maxUrlLength: this.maxUrlLength }
+    });
+    if (link.clipboardText !== null && !await this.copyReport(link.clipboardText)) {
+      return;
+    }
+    window.open(link.url, "_blank");
+  }
+  /**
+   * Builds the prefilled bug-report URL, with the environment only.
    *
    * @returns The link.
    */
@@ -41,8 +122,23 @@ class OpenBugReportCommandHandler extends OpenGitHubCommandHandler {
       pluginId: this.pluginId
     });
   }
+  async copyReport(text) {
+    try {
+      await activeWindow.navigator.clipboard.writeText(text);
+      new Notice(t(($) => $.obsidianLib.bugReport.clipboardCopied), CLIPBOARD_NOTICE_DURATION_IN_MILLISECONDS);
+      return true;
+    } catch {
+      return await copyTextManually({
+        app: this.app,
+        message: t(($) => $.obsidianLib.bugReport.copyManuallyMessage),
+        okButtonText: t(($) => $.obsidianLib.bugReport.openIssueForm),
+        text,
+        title: t(($) => $.obsidianLib.bugReport.copyManuallyTitle)
+      });
+    }
+  }
 }
 export {
   OpenBugReportCommandHandler
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/command-handlers/open-bug-report-command-handler.ts"],"sourcesContent":["/**\n * @file\n *\n * Handles the \"Report a bug\" command.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { Notice } from 'obsidian';\n\nimport type { BugReportDiagnosticSection } from '../bug-report-diagnostics.ts';\n\nimport {\n  buildBugReportIssueFormLink,\n  formatBugReportEnvironment,\n  getBugReportEnvironment,\n  getBugReportIssueFormUrl\n} from '../bug-report.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { copyTextManually } from '../modals/copy-text-manually.ts';\nimport { reviewBugReportDiagnostics } from '../modals/review-bug-report-diagnostics.ts';\nimport { OpenGitHubCommandHandler } from './open-git-hub-command-handler.ts';\n\n/**\n * Constructor parameters for {@link OpenBugReportCommandHandler}.\n */\nexport interface OpenBugReportCommandHandlerConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Gets the optional diagnostics the report can carry, such as a `BugReportLogBuffer`'s section or the\n   * plugin's own redacted settings. Called each time the command runs. When it returns any section, the\n   * user reviews them and chooses which to include before the form opens; a potentially private section\n   * starts excluded. Leave it out to open the form with the environment only, as before.\n   */\n  readonly getDiagnostics?: () => Promisable<readonly BugReportDiagnosticSection[]>;\n\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The most characters the encoded link may have before the report moves to the clipboard.\n   *\n   * @default `DEFAULT_BUG_REPORT_MAX_URL_LENGTH`\n   */\n  readonly maxUrlLength?: number;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n// Long enough to read the paste instruction while the browser opens.\nconst CLIPBOARD_NOTICE_DURATION_IN_MILLISECONDS = 15_000;\n\n/**\n * A command handler that opens the plugin's bug-report issue form on GitHub, prefilled with the\n * environment and any diagnostics the user agreed to include. See {@link getBugReportIssueFormUrl} for the\n * field ids the form must use, and {@link buildBugReportIssueFormLink} for what happens to a report too long\n * for a link.\n */\nexport class OpenBugReportCommandHandler extends OpenGitHubCommandHandler {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * Gets the optional diagnostics the report can carry.\n   */\n  protected readonly getDiagnostics: (() => Promisable<readonly BugReportDiagnosticSection[]>) | undefined;\n\n  /**\n   * The most characters the encoded link may have before the report moves to the clipboard.\n   */\n  protected readonly maxUrlLength: number | undefined;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  protected readonly pluginId: string;\n\n  /**\n   * Constructs a new instance.\n   *\n   * @param params - Constructor parameters.\n   */\n  public constructor(params: OpenBugReportCommandHandlerConstructorParams) {\n    super({\n      gitHubRepo: params.gitHubRepo,\n      icon: 'bug',\n      id: 'report-bug',\n      name: 'Report a bug'\n    });\n\n    this.app = params.app;\n    this.getDiagnostics = params.getDiagnostics;\n    this.maxUrlLength = params.maxUrlLength;\n    this.pluginId = params.pluginId;\n  }\n\n  /**\n   * Lets the user review the diagnostics, if any, then opens the issue form. When the report is too long\n   * for a link, it is copied to the clipboard first, or shown for copying by hand when the clipboard\n   * refuses it.\n   */\n  public override async execute(): Promise<void> {\n    if (!this.canExecute()) {\n      return;\n    }\n\n    const environment = await getBugReportEnvironment({ app: this.app, pluginId: this.pluginId });\n    const sections = await this.getDiagnostics?.() ?? [];\n    let diagnostics: readonly BugReportDiagnosticSection[] = [];\n    if (sections.length > 0) {\n      const reviewedSections = await reviewBugReportDiagnostics({\n        alwaysIncludedText: formatBugReportEnvironment(environment),\n        app: this.app,\n        sections\n      });\n      if (reviewedSections === null) {\n        return;\n      }\n      diagnostics = reviewedSections;\n    }\n\n    const link = buildBugReportIssueFormLink({\n      diagnostics,\n      environment,\n      gitHubRepo: this.gitHubRepo,\n      ...this.maxUrlLength !== undefined && { maxUrlLength: this.maxUrlLength }\n    });\n\n    if (link.clipboardText !== null && !await this.copyReport(link.clipboardText)) {\n      return;\n    }\n\n    window.open(link.url, '_blank');\n  }\n\n  /**\n   * Builds the prefilled bug-report URL, with the environment only.\n   *\n   * @returns The link.\n   */\n  protected override async getUrl(): Promise<string> {\n    return getBugReportIssueFormUrl({\n      app: this.app,\n      gitHubRepo: this.gitHubRepo,\n      pluginId: this.pluginId\n    });\n  }\n\n  private async copyReport(text: string): Promise<boolean> {\n    try {\n      // The clipboard of the focused window: a popout's document is the one that holds the focus.\n      await activeWindow.navigator.clipboard.writeText(text);\n      new Notice(t(($) => $.obsidianLib.bugReport.clipboardCopied), CLIPBOARD_NOTICE_DURATION_IN_MILLISECONDS);\n      return true;\n    } catch {\n      return await copyTextManually({\n        app: this.app,\n        message: t(($) => $.obsidianLib.bugReport.copyManuallyMessage),\n        okButtonText: t(($) => $.obsidianLib.bugReport.openIssueForm),\n        text,\n        title: t(($) => $.obsidianLib.bugReport.copyManuallyTitle)\n      });\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,SAAS,cAAc;AAIvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,SAAS;AAClB,SAAS,wBAAwB;AACjC,SAAS,kCAAkC;AAC3C,SAAS,gCAAgC;AAsCzC,MAAM,4CAA4C;AAQ3C,MAAM,oCAAoC,yBAAyB;AAAA;AAAA;AAAA;AAAA,EAIrD;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOZ,YAAY,QAAsD;AACvE,UAAM;AAAA,MACJ,YAAY,OAAO;AAAA,MACnB,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,MAAM;AAAA,IACR,CAAC;AAED,SAAK,MAAM,OAAO;AAClB,SAAK,iBAAiB,OAAO;AAC7B,SAAK,eAAe,OAAO;AAC3B,SAAK,WAAW,OAAO;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAsB,UAAyB;AAC7C,QAAI,CAAC,KAAK,WAAW,GAAG;AACtB;AAAA,IACF;AAEA,UAAM,cAAc,MAAM,wBAAwB,EAAE,KAAK,KAAK,KAAK,UAAU,KAAK,SAAS,CAAC;AAC5F,UAAM,WAAW,MAAM,KAAK,iBAAiB,KAAK,CAAC;AACnD,QAAI,cAAqD,CAAC;AAC1D,QAAI,SAAS,SAAS,GAAG;AACvB,YAAM,mBAAmB,MAAM,2BAA2B;AAAA,QACxD,oBAAoB,2BAA2B,WAAW;AAAA,QAC1D,KAAK,KAAK;AAAA,QACV;AAAA,MACF,CAAC;AACD,UAAI,qBAAqB,MAAM;AAC7B;AAAA,MACF;AACA,oBAAc;AAAA,IAChB;AAEA,UAAM,OAAO,4BAA4B;AAAA,MACvC;AAAA,MACA;AAAA,MACA,YAAY,KAAK;AAAA,MACjB,GAAG,KAAK,iBAAiB,UAAa,EAAE,cAAc,KAAK,aAAa;AAAA,IAC1E,CAAC;AAED,QAAI,KAAK,kBAAkB,QAAQ,CAAC,MAAM,KAAK,WAAW,KAAK,aAAa,GAAG;AAC7E;AAAA,IACF;AAEA,WAAO,KAAK,KAAK,KAAK,QAAQ;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAyB,SAA0B;AACjD,WAAO,yBAAyB;AAAA,MAC9B,KAAK,KAAK;AAAA,MACV,YAAY,KAAK;AAAA,MACjB,UAAU,KAAK;AAAA,IACjB,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,WAAW,MAAgC;AACvD,QAAI;AAEF,YAAM,aAAa,UAAU,UAAU,UAAU,IAAI;AACrD,UAAI,OAAO,EAAE,CAAC,MAAM,EAAE,YAAY,UAAU,eAAe,GAAG,yCAAyC;AACvG,aAAO;AAAA,IACT,QAAQ;AACN,aAAO,MAAM,iBAAiB;AAAA,QAC5B,KAAK,KAAK;AAAA,QACV,SAAS,EAAE,CAAC,MAAM,EAAE,YAAY,UAAU,mBAAmB;AAAA,QAC7D,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,UAAU,aAAa;AAAA,QAC5D;AAAA,QACA,OAAO,EAAE,CAAC,MAAM,EAAE,YAAY,UAAU,iBAAiB;AAAA,MAC3D,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/lib/esm/components/all-windows-status-bar-item-component.d.mts

@@ -0,0 +1,146 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, and
+ * removes only its own items when a window closes or the component unloads.
+ *
+ * Read from Obsidian `1.15.1`: the main window builds `body > .app-container > .status-bar`, and
+ * `Plugin.addStatusBarItem` is a `.status-bar-item` created in it. A popout builds `body > .app-container` with the
+ * workspace only, and **no status bar**. `app.css` styles `.status-bar` without scoping it to a window, so a
+ * `.status-bar` created inside a popout's `.app-container` looks and sits exactly like the main one. By default
+ * this component creates that bar in a popout that lacks one, and marks it with
+ * {@link WINDOW_STATUS_BAR_CSS_CLASS}. The marker is a wire constant shared by every copy of this library: any copy
+ * reuses a marked bar, and whichever copy removes the last item from it removes the bar too.
+ *
+ * Mobile has no popouts, and `app.css` hides `.status-bar` under `.is-mobile`, so on mobile the component creates
+ * nothing and never calls the render callback.
+ */
+import type { App, Component } from 'obsidian';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * The class that marks a status bar this library created in a window that had none.
+ * Other copies of the library match it, so its value must never change.
+ */
+export declare const WINDOW_STATUS_BAR_CSS_CLASS = "obsidian-lib-window-status-bar";
+/**
+ * Parameters for the {@link AllWindowsStatusBarItemComponent} constructor.
+ */
+export interface AllWindowsStatusBarItemComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Extra CSS classes for each item.
+     */
+    readonly cls?: readonly string[];
+    /**
+     * The plugin id. When given, each item gets the `plugin-<id>` class that `Plugin.addStatusBarItem` adds, so
+     * themes and CSS snippets that target the plugin's status-bar items match these too.
+     */
+    readonly pluginId?: string;
+    /**
+     * Renders the item of one window. Called when the item is created and again by
+     * {@link AllWindowsStatusBarItemComponent.refresh}, so it must be safe to call repeatedly on the same element.
+     *
+     * @param params - The item and its window.
+     */
+    readonly render: (params: AllWindowsStatusBarItemRenderParams) => void;
+    /**
+     * Whether to create a status bar in a window that has none, as every popout in Obsidian `1.15.1` does.
+     * When `false`, such a window gets no item. Defaults to `true`.
+     */
+    readonly shouldCreateMissingStatusBar?: boolean;
+}
+/**
+ * Parameters passed to {@link AllWindowsStatusBarItemComponentConstructorParams.render}.
+ */
+export interface AllWindowsStatusBarItemRenderParams {
+    /**
+     * The status-bar item owned by this component in {@link win}.
+     */
+    readonly el: HTMLElement;
+    /**
+     * The window the item is in. Use its document for anything the render creates outside the item.
+     */
+    readonly win: Window;
+}
+/**
+ * Parameters for {@link registerAllWindowsStatusBarItem}.
+ */
+export interface RegisterAllWindowsStatusBarItemParams extends AllWindowsStatusBarItemComponentConstructorParams {
+    /**
+     * The component that owns the items: they are removed when it unloads.
+     */
+    readonly component: Component;
+}
+/**
+ * Shows one status-bar item in the main window and in every desktop popout while loaded.
+ */
+export declare class AllWindowsStatusBarItemComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The CSS classes added to each item.
+     */
+    protected readonly itemClasses: readonly string[];
+    /**
+     * Renders the item of one window.
+     */
+    protected readonly renderItem: (params: AllWindowsStatusBarItemRenderParams) => void;
+    /**
+     * Whether a status bar is created in a window that has none.
+     */
+    protected readonly shouldCreateMissingStatusBar: boolean;
+    private readonly itemElsByWindow;
+    /**
+     * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.
+     *
+     * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.
+     */
+    constructor(params: AllWindowsStatusBarItemComponentConstructorParams);
+    /**
+     * Gets the item of a window.
+     *
+     * @param win - The window.
+     * @returns The item, or `null` when the window has none.
+     */
+    getItemEl(win: Window): HTMLElement | null;
+    /**
+     * Gets the items of every window that has one.
+     *
+     * @returns The items.
+     */
+    getItemEls(): HTMLElement[];
+    /**
+     * Creates the item in every window, now and as popouts open. A no-op on mobile.
+     */
+    onload(): void;
+    /**
+     * Renders the item of every window again.
+     */
+    refresh(): void;
+    private attach;
+    private findOrCreateStatusBar;
+}
+/**
+ * Gets the class `Plugin.addStatusBarItem` adds to a plugin's status-bar items.
+ * It copies Obsidian `1.15.1` exactly, including that only the first disallowed character is replaced.
+ *
+ * @param pluginId - The plugin id.
+ * @returns The CSS class.
+ */
+export declare function getPluginStatusBarItemCssClass(pluginId: string): string;
+/**
+ * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, until
+ * the owning component unloads.
+ *
+ * @param params - The {@link RegisterAllWindowsStatusBarItemParams}. The owner must be loaded.
+ * @returns The {@link AllWindowsStatusBarItemComponent}. Call its {@link AllWindowsStatusBarItemComponent.refresh} to
+ *   render every item again, or remove it from the owner to stop early.
+ */
+export declare function registerAllWindowsStatusBarItem(params: RegisterAllWindowsStatusBarItemParams): AllWindowsStatusBarItemComponent;

package/dist/lib/esm/components/all-windows-status-bar-item-component.mjs

@@ -0,0 +1,154 @@
+/*
+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 { Platform } from "obsidian";
+import { AllWindowsEventComponent } from "./all-windows-event-component.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+const WINDOW_STATUS_BAR_CSS_CLASS = "obsidian-lib-window-status-bar";
+const APP_CONTAINER_CSS_CLASS = "app-container";
+const STATUS_BAR_CSS_CLASS = "status-bar";
+const STATUS_BAR_ITEM_CSS_CLASS = "status-bar-item";
+class AllWindowsStatusBarItemComponent extends ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The CSS classes added to each item.
+   */
+  itemClasses;
+  /**
+   * Renders the item of one window.
+   */
+  renderItem;
+  /**
+   * Whether a status bar is created in a window that has none.
+   */
+  shouldCreateMissingStatusBar;
+  itemElsByWindow = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.
+   *
+   * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.renderItem = params.render;
+    this.shouldCreateMissingStatusBar = params.shouldCreateMissingStatusBar ?? true;
+    this.itemClasses = [
+      STATUS_BAR_ITEM_CSS_CLASS,
+      ...params.pluginId === void 0 ? [] : [getPluginStatusBarItemCssClass(params.pluginId)],
+      ...params.cls ?? []
+    ];
+  }
+  /**
+   * Gets the item of a window.
+   *
+   * @param win - The window.
+   * @returns The item, or `null` when the window has none.
+   */
+  getItemEl(win) {
+    return this.itemElsByWindow.get(win) ?? null;
+  }
+  /**
+   * Gets the items of every window that has one.
+   *
+   * @returns The items.
+   */
+  getItemEls() {
+    return [...this.itemElsByWindow.values()];
+  }
+  /**
+   * Creates the item in every window, now and as popouts open. A no-op on mobile.
+   */
+  onload() {
+    super.onload();
+    if (Platform.isMobile) {
+      return;
+    }
+    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));
+    allWindowsEventComponent.registerAllWindowsHandler((win) => this.attach(win));
+  }
+  /**
+   * Renders the item of every window again.
+   */
+  refresh() {
+    for (const [win, el] of this.itemElsByWindow) {
+      this.renderItem({ el, win });
+    }
+  }
+  attach(win) {
+    const statusBarEl = this.findOrCreateStatusBar(win.document);
+    if (!statusBarEl) {
+      return null;
+    }
+    const el = statusBarEl.createDiv({ cls: [...this.itemClasses] });
+    this.itemElsByWindow.set(win, el);
+    this.renderItem({ el, win });
+    return () => {
+      this.itemElsByWindow.delete(win);
+      el.remove();
+      if (statusBarEl.classList.contains(WINDOW_STATUS_BAR_CSS_CLASS) && !statusBarEl.querySelector(`:scope > .${STATUS_BAR_ITEM_CSS_CLASS}`)) {
+        statusBarEl.remove();
+      }
+    };
+  }
+  findOrCreateStatusBar(doc) {
+    const appContainerEl = doc.body.querySelector(`:scope > .${APP_CONTAINER_CSS_CLASS}`);
+    if (!appContainerEl) {
+      return null;
+    }
+    const statusBarEl = appContainerEl.querySelector(`:scope > .${STATUS_BAR_CSS_CLASS}`);
+    if (statusBarEl) {
+      return statusBarEl;
+    }
+    if (!this.shouldCreateMissingStatusBar) {
+      return null;
+    }
+    return appContainerEl.createDiv({ cls: [STATUS_BAR_CSS_CLASS, WINDOW_STATUS_BAR_CSS_CLASS] });
+  }
+}
+function getPluginStatusBarItemCssClass(pluginId) {
+  return `plugin-${pluginId.toLowerCase().replace(/[^_a-zA-Z0-9-]/, "-")}`;
+}
+function registerAllWindowsStatusBarItem(params) {
+  const { component, ...constructorParams } = params;
+  return component.addChild(new AllWindowsStatusBarItemComponent(constructorParams));
+}
+export {
+  AllWindowsStatusBarItemComponent,
+  WINDOW_STATUS_BAR_CSS_CLASS,
+  getPluginStatusBarItemCssClass,
+  registerAllWindowsStatusBarItem
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/all-windows-status-bar-item-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, and\n * removes only its own items when a window closes or the component unloads.\n *\n * Read from Obsidian `1.15.1`: the main window builds `body > .app-container > .status-bar`, and\n * `Plugin.addStatusBarItem` is a `.status-bar-item` created in it. A popout builds `body > .app-container` with the\n * workspace only, and **no status bar**. `app.css` styles `.status-bar` without scoping it to a window, so a\n * `.status-bar` created inside a popout's `.app-container` looks and sits exactly like the main one. By default\n * this component creates that bar in a popout that lacks one, and marks it with\n * {@link WINDOW_STATUS_BAR_CSS_CLASS}. The marker is a wire constant shared by every copy of this library: any copy\n * reuses a marked bar, and whichever copy removes the last item from it removes the bar too.\n *\n * Mobile has no popouts, and `app.css` hides `.status-bar` under `.is-mobile`, so on mobile the component creates\n * nothing and never calls the render callback.\n */\n\nimport type {\n  App,\n  Component\n} from 'obsidian';\n\nimport { Platform } from 'obsidian';\n\nimport { AllWindowsEventComponent } from './all-windows-event-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * The class that marks a status bar this library created in a window that had none.\n * Other copies of the library match it, so its value must never change.\n */\nexport const WINDOW_STATUS_BAR_CSS_CLASS = 'obsidian-lib-window-status-bar';\n\nconst APP_CONTAINER_CSS_CLASS = 'app-container';\nconst STATUS_BAR_CSS_CLASS = 'status-bar';\nconst STATUS_BAR_ITEM_CSS_CLASS = 'status-bar-item';\n\n/**\n * Parameters for the {@link AllWindowsStatusBarItemComponent} constructor.\n */\nexport interface AllWindowsStatusBarItemComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Extra CSS classes for each item.\n   */\n  readonly cls?: readonly string[];\n\n  /**\n   * The plugin id. When given, each item gets the `plugin-<id>` class that `Plugin.addStatusBarItem` adds, so\n   * themes and CSS snippets that target the plugin's status-bar items match these too.\n   */\n  readonly pluginId?: string;\n\n  /**\n   * Renders the item of one window. Called when the item is created and again by\n   * {@link AllWindowsStatusBarItemComponent.refresh}, so it must be safe to call repeatedly on the same element.\n   *\n   * @param params - The item and its window.\n   */\n  readonly render: (params: AllWindowsStatusBarItemRenderParams) => void;\n\n  /**\n   * Whether to create a status bar in a window that has none, as every popout in Obsidian `1.15.1` does.\n   * When `false`, such a window gets no item. Defaults to `true`.\n   */\n  readonly shouldCreateMissingStatusBar?: boolean;\n}\n\n/**\n * Parameters passed to {@link AllWindowsStatusBarItemComponentConstructorParams.render}.\n */\nexport interface AllWindowsStatusBarItemRenderParams {\n  /**\n   * The status-bar item owned by this component in {@link win}.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The window the item is in. Use its document for anything the render creates outside the item.\n   */\n  readonly win: Window;\n}\n\n/**\n * Parameters for {@link registerAllWindowsStatusBarItem}.\n */\nexport interface RegisterAllWindowsStatusBarItemParams extends AllWindowsStatusBarItemComponentConstructorParams {\n  /**\n   * The component that owns the items: they are removed when it unloads.\n   */\n  readonly component: Component;\n}\n\n/**\n * Shows one status-bar item in the main window and in every desktop popout while loaded.\n */\nexport class AllWindowsStatusBarItemComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The CSS classes added to each item.\n   */\n  protected readonly itemClasses: readonly string[];\n\n  /**\n   * Renders the item of one window.\n   */\n  protected readonly renderItem: (params: AllWindowsStatusBarItemRenderParams) => void;\n\n  /**\n   * Whether a status bar is created in a window that has none.\n   */\n  protected readonly shouldCreateMissingStatusBar: boolean;\n\n  private readonly itemElsByWindow = new Map<Window, HTMLElement>();\n\n  /**\n   * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.\n   *\n   * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.\n   */\n  public constructor(params: AllWindowsStatusBarItemComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.renderItem = params.render;\n    this.shouldCreateMissingStatusBar = params.shouldCreateMissingStatusBar ?? true;\n    this.itemClasses = [\n      STATUS_BAR_ITEM_CSS_CLASS,\n      ...params.pluginId === undefined ? [] : [getPluginStatusBarItemCssClass(params.pluginId)],\n      ...params.cls ?? []\n    ];\n  }\n\n  /**\n   * Gets the item of a window.\n   *\n   * @param win - The window.\n   * @returns The item, or `null` when the window has none.\n   */\n  public getItemEl(win: Window): HTMLElement | null {\n    return this.itemElsByWindow.get(win) ?? null;\n  }\n\n  /**\n   * Gets the items of every window that has one.\n   *\n   * @returns The items.\n   */\n  public getItemEls(): HTMLElement[] {\n    return [...this.itemElsByWindow.values()];\n  }\n\n  /**\n   * Creates the item in every window, now and as popouts open. A no-op on mobile.\n   */\n  public override onload(): void {\n    super.onload();\n\n    if (Platform.isMobile) {\n      return;\n    }\n\n    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));\n    allWindowsEventComponent.registerAllWindowsHandler((win) => this.attach(win));\n  }\n\n  /**\n   * Renders the item of every window again.\n   */\n  public refresh(): void {\n    for (const [win, el] of this.itemElsByWindow) {\n      this.renderItem({ el, win });\n    }\n  }\n\n  private attach(win: Window): (() => void) | null {\n    const statusBarEl = this.findOrCreateStatusBar(win.document);\n    if (!statusBarEl) {\n      return null;\n    }\n\n    const el = statusBarEl.createDiv({ cls: [...this.itemClasses] });\n    this.itemElsByWindow.set(win, el);\n    this.renderItem({ el, win });\n\n    return () => {\n      this.itemElsByWindow.delete(win);\n      el.remove();\n      if (statusBarEl.classList.contains(WINDOW_STATUS_BAR_CSS_CLASS) && !statusBarEl.querySelector(`:scope > .${STATUS_BAR_ITEM_CSS_CLASS}`)) {\n        statusBarEl.remove();\n      }\n    };\n  }\n\n  private findOrCreateStatusBar(doc: Document): HTMLElement | null {\n    const appContainerEl = doc.body.querySelector<HTMLElement>(`:scope > .${APP_CONTAINER_CSS_CLASS}`);\n    if (!appContainerEl) {\n      return null;\n    }\n\n    const statusBarEl = appContainerEl.querySelector<HTMLElement>(`:scope > .${STATUS_BAR_CSS_CLASS}`);\n    if (statusBarEl) {\n      return statusBarEl;\n    }\n\n    if (!this.shouldCreateMissingStatusBar) {\n      return null;\n    }\n\n    return appContainerEl.createDiv({ cls: [STATUS_BAR_CSS_CLASS, WINDOW_STATUS_BAR_CSS_CLASS] });\n  }\n}\n\n/**\n * Gets the class `Plugin.addStatusBarItem` adds to a plugin's status-bar items.\n * It copies Obsidian `1.15.1` exactly, including that only the first disallowed character is replaced.\n *\n * @param pluginId - The plugin id.\n * @returns The CSS class.\n */\nexport function getPluginStatusBarItemCssClass(pluginId: string): string {\n  return `plugin-${pluginId.toLowerCase().replace(/[^_a-zA-Z0-9-]/, '-')}`;\n}\n\n/**\n * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, until\n * the owning component unloads.\n *\n * @param params - The {@link RegisterAllWindowsStatusBarItemParams}. The owner must be loaded.\n * @returns The {@link AllWindowsStatusBarItemComponent}. Call its {@link AllWindowsStatusBarItemComponent.refresh} to\n *   render every item again, or remove it from the owner to stop early.\n */\nexport function registerAllWindowsStatusBarItem(params: RegisterAllWindowsStatusBarItemParams): AllWindowsStatusBarItemComponent {\n  const { component, ...constructorParams } = params;\n  return component.addChild(new AllWindowsStatusBarItemComponent(constructorParams));\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/components/embed-extensions-component.d.mts

@@ -26,6 +26,14 @@ export declare class EmbedExtensionsComponent extends ComponentEx {
      * Registers the specified file extensions with the given embed type in the Obsidian app.
      * The extensions will be automatically unregistered when the component is unloaded.
      *
+     * The registration is all or nothing: Obsidian throws for an extension that is already registered (by the core or by
+     * another plugin), and in that case every extension this call registered before the conflict is unregistered again
+     * before the error is rethrown. An extension registered by someone else is never unregistered.
+     *
+     * The creator serves every surface that loads an embed: `![[file.ext#subpath]]` in Reading view and Live Preview,
+     * canvas file nodes and the page-preview hover popover. It receives the link's subpath with its leading `#`, or an
+     * empty string. Returning `null` makes Obsidian fall back to its generic file embed.
+     *
      * @param extensions - An array of file extensions to register.
      * @param embedCreator - The embed creator function to associate with the extensions.
      *

package/dist/lib/esm/components/embed-extensions-component.mjs

@@ -19,6 +19,14 @@ class EmbedExtensionsComponent extends ComponentEx {
    * Registers the specified file extensions with the given embed type in the Obsidian app.
    * The extensions will be automatically unregistered when the component is unloaded.
    *
+   * The registration is all or nothing: Obsidian throws for an extension that is already registered (by the core or by
+   * another plugin), and in that case every extension this call registered before the conflict is unregistered again
+   * before the error is rethrown. An extension registered by someone else is never unregistered.
+   *
+   * The creator serves every surface that loads an embed: `![[file.ext#subpath]]` in Reading view and Live Preview,
+   * canvas file nodes and the page-preview hover popover. It receives the link's subpath with its leading `#`, or an
+   * empty string. Returning `null` makes Obsidian fall back to its generic file embed.
+   *
    * @param extensions - An array of file extensions to register.
    * @param embedCreator - The embed creator function to associate with the extensions.
    *
@@ -29,13 +37,22 @@ class EmbedExtensionsComponent extends ComponentEx {
    */
   registerExtensions(extensions, embedCreator) {
     this.ensureLoaded();
-    this.app.embedRegistry.registerExtensions(extensions, embedCreator);
+    const registeredExtensions = [];
+    try {
+      for (const extension of extensions) {
+        this.app.embedRegistry.registerExtension(extension, embedCreator);
+        registeredExtensions.push(extension);
+      }
+    } catch (error) {
+      this.app.embedRegistry.unregisterExtensions(registeredExtensions);
+      throw error;
+    }
     this.register(() => {
-      this.app.embedRegistry.unregisterExtensions(extensions);
+      this.app.embedRegistry.unregisterExtensions(registeredExtensions);
     });
   }
 }
 export {
   EmbedExtensionsComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/components/embeddable-markdown-editor-component.d.mts

@@ -157,6 +157,15 @@ export declare class EmbeddableMarkdownEditorComponent extends ComponentEx {
      * @returns The CodeMirror view.
      */
     get editorView(): EditorView;
+    /**
+     * Whether the editor holds the focus within its window.
+     *
+     * Unlike CodeMirror's `EditorView.hasFocus`, this does not also require the window to have the operating system's
+     * focus, so it stays `true` while the user is in another application or another Obsidian window is in front.
+     *
+     * @returns `true` when the editor's content element is its document's active element.
+     */
+    get hasFocus(): boolean;
     /**
      * The current document.
      *