@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

package/dist/lib/esm/markdown-view.d.mts

@@ -1,10 +1,34 @@
 /// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
 /**
  * @file
  *
  * Utilities for working with MarkdownView
  */
-import type { MarkdownView } from 'obsidian';
+import type { App } from 'obsidian';
+import { MarkdownView } from 'obsidian';
+/**
+ * Options for {@link rerenderPreviews}.
+ */
+export interface RerenderPreviewsParams {
+    /**
+     * Stops waiting for the renders when aborted, rejecting with the signal's reason. The renders already requested still
+     * happen.
+     */
+    readonly abortSignal?: AbortSignal;
+    /**
+     * The Obsidian app.
+     */
+    readonly app: App;
+    /**
+     * The code block language whose blocks to render again, matched exactly and case-sensitively, the way Obsidian matches a
+     * code block processor's language. Only the sections holding such a block are rendered again, and a view holding none
+     * is left alone.
+     *
+     * @default `null`, which renders every section of every Reading view again
+     */
+    readonly language?: null | string;
+}
 /**
  * Get the full HTML content of the current MarkdownView
  *
@@ -12,3 +36,26 @@ import type { MarkdownView } from 'obsidian';
  * @returns The full HTML of the MarkdownView
  */
 export declare function getFullContentHtml(view: MarkdownView): string;
+/**
+ * Renders the open Reading views again, so a markdown post-processor or code block processor registered or reconfigured
+ * since they rendered applies to them.
+ *
+ * It covers every Markdown view in every window, popouts included. A full refresh is what Obsidian itself does when a
+ * post-processor is registered: every section is rendered again, except the header holding the inline title and the
+ * properties, and the footer holding the backlinks, which keep their DOM. With a `language`, only the sections holding a
+ * code block of that language are rendered again. The note is never written, the view mode never changes, and the
+ * scroll position is kept by Obsidian's renderer.
+ *
+ * The promise settles once every view SHOWN in Reading view has finished rendering, the promises of asynchronous
+ * post-processors included. A preview that is not shown (a background tab, a view in editing mode) is marked to render
+ * again when it is next shown, and is not waited for, since Obsidian does not render it until then. A view that is closed,
+ * hidden or switched out of Reading view while rendering stops being waited for. A post-processor whose promise never
+ * settles, or rejects, keeps its view's render open, exactly as it keeps Obsidian's own render open; pass an
+ * `abortSignal` to bound the wait.
+ *
+ * Hover popovers, embeds, canvas cards and Live Preview widgets are not refreshed.
+ *
+ * @param params - The options.
+ * @returns A promise that resolves once the shown Reading views have rendered.
+ */
+export declare function rerenderPreviews(params: RerenderPreviewsParams): Promise<void>;

package/dist/lib/esm/markdown-view.mjs

@@ -2,7 +2,91 @@
 THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  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;
+}
 
+ensureDisposeSymbols();
+ensureBrowserProcess();
+})();
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import { onAbort } from "@mnaoumov/typescript-lib/abort-controller";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import {
+  Component,
+  MarkdownView
+} from "obsidian";
 function getFullContentHtml(view) {
   const codeMirror = view.editor.cm;
   codeMirror.viewState.printing = true;
@@ -12,7 +96,113 @@ function getFullContentHtml(view) {
   codeMirror.measure();
   return html;
 }
+async function rerenderPreviews(params) {
+  var _stack = [];
+  try {
+    const { abortSignal, app, language = null } = params;
+    abortSignal?.throwIfAborted();
+    const views = [];
+    app.workspace.iterateAllLeaves((leaf) => {
+      if (leaf.view instanceof MarkdownView) {
+        views.push(leaf.view);
+      }
+    });
+    const waits = [];
+    for (const view of views) {
+      const isShown = isPreviewShown(view);
+      const scroll = isShown ? view.previewMode.getScroll() : null;
+      if (language === null) {
+        view.previewMode.rerender(true);
+      } else {
+        const sections = getSectionsWithLanguage(view.previewMode, language);
+        if (sections.length === 0) {
+          continue;
+        }
+        rerenderSections(view.previewMode, sections);
+      }
+      if (scroll !== null) {
+        waits.push(waitForPreviewRender(app, view, scroll));
+      }
+    }
+    if (waits.length === 0) {
+      return;
+    }
+    const allRendered = Promise.all(waits);
+    if (!abortSignal) {
+      await allRendered;
+      return;
+    }
+    let resolveAborted = noop;
+    const aborted = new Promise((resolve) => {
+      resolveAborted = resolve;
+    });
+    const _abortListener = __using(_stack, onAbort(abortSignal, () => {
+      resolveAborted();
+    }));
+    await Promise.race([allRendered, aborted]);
+    abortSignal.throwIfAborted();
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function getSectionsWithLanguage(previewMode, language) {
+  const { renderer } = previewMode;
+  const selector = `code.language-${CSS.escape(language)}`;
+  const parser = new DOMParser();
+  return renderer.sections.filter(
+    (section) => section !== renderer.header && section !== renderer.footer && !!section.html && parser.parseFromString(section.html, "text/html").querySelector(selector) !== null
+  );
+}
+function isPreviewShown(view) {
+  if (view.getMode() !== "preview") {
+    return false;
+  }
+  const { previewEl } = view.previewMode.renderer;
+  return previewEl.isConnected && previewEl.offsetParent !== null && previewEl.offsetWidth > 0;
+}
+function rerenderSections(previewMode, sections) {
+  for (const section of sections) {
+    section.rendered = false;
+    section.el.empty();
+  }
+  previewMode.renderer.queueRender();
+}
+async function waitForPreviewRender(app, view, scroll) {
+  const { previewMode } = view;
+  const isRendered = await new Promise((resolve) => {
+    let isSettled = false;
+    const watcher = new Component();
+    function settle(isRenderedNow) {
+      if (isSettled) {
+        return;
+      }
+      isSettled = true;
+      previewMode.removeChild(watcher);
+      resolve(isRenderedNow);
+    }
+    function settleIfHidden() {
+      if (!isPreviewShown(view)) {
+        settle(false);
+      }
+    }
+    watcher.register(() => {
+      settle(false);
+    });
+    watcher.registerEvent(app.workspace.on("layout-change", settleIfHidden));
+    watcher.registerEvent(app.workspace.on("active-leaf-change", settleIfHidden));
+    previewMode.addChild(watcher);
+    previewMode.renderer.onRendered(() => {
+      settle(true);
+    });
+  });
+  if (isRendered) {
+    previewMode.applyScroll(scroll);
+  }
+}
 export {
-  getFullContentHtml
+  getFullContentHtml,
+  rerenderPreviews
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL21hcmtkb3duLXZpZXcudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBVdGlsaXRpZXMgZm9yIHdvcmtpbmcgd2l0aCBNYXJrZG93blZpZXdcbiAqL1xuXG5pbXBvcnQgdHlwZSB7IE1hcmtkb3duVmlldyB9IGZyb20gJ29ic2lkaWFuJztcblxuLyoqXG4gKiBHZXQgdGhlIGZ1bGwgSFRNTCBjb250ZW50IG9mIHRoZSBjdXJyZW50IE1hcmtkb3duVmlld1xuICpcbiAqIEBwYXJhbSB2aWV3IC0gVGhlIE1hcmtkb3duVmlldyB0byBnZXQgdGhlIEhUTUwgZnJvbVxuICogQHJldHVybnMgVGhlIGZ1bGwgSFRNTCBvZiB0aGUgTWFya2Rvd25WaWV3XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRGdWxsQ29udGVudEh0bWwodmlldzogTWFya2Rvd25WaWV3KTogc3RyaW5nIHtcbiAgY29uc3QgY29kZU1pcnJvciA9IHZpZXcuZWRpdG9yLmNtO1xuICBjb2RlTWlycm9yLnZpZXdTdGF0ZS5wcmludGluZyA9IHRydWU7XG4gIGNvZGVNaXJyb3IubWVhc3VyZSgpO1xuICBjb25zdCBodG1sID0gdmlldy5jb250ZW50RWwuaW5uZXJIVE1MO1xuICBjb2RlTWlycm9yLnZpZXdTdGF0ZS5wcmludGluZyA9IGZhbHNlO1xuICBjb2RlTWlycm9yLm1lYXN1cmUoKTtcbiAgcmV0dXJuIGh0bWw7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQWNPLFNBQVMsbUJBQW1CLE1BQTRCO0FBQzdELFFBQU0sYUFBYSxLQUFLLE9BQU87QUFDL0IsYUFBVyxVQUFVLFdBQVc7QUFDaEMsYUFBVyxRQUFRO0FBQ25CLFFBQU0sT0FBTyxLQUFLLFVBQVU7QUFDNUIsYUFBVyxVQUFVLFdBQVc7QUFDaEMsYUFBVyxRQUFRO0FBQ25CLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/markdown-view.ts"],"sourcesContent":["/**\n * @file\n *\n * Utilities for working with MarkdownView\n */\n\nimport type { RendererSection } from '@obsidian-typings/obsidian-public-latest';\nimport type {\n  App,\n  MarkdownPreviewView\n} from 'obsidian';\n\nimport { onAbort } from '@mnaoumov/typescript-lib/abort-controller';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport {\n  Component,\n  MarkdownView\n} from 'obsidian';\n\n/**\n * Options for {@link rerenderPreviews}.\n */\nexport interface RerenderPreviewsParams {\n  /**\n   * Stops waiting for the renders when aborted, rejecting with the signal's reason. The renders already requested still\n   * happen.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The Obsidian app.\n   */\n  readonly app: App;\n\n  /**\n   * The code block language whose blocks to render again, matched exactly and case-sensitively, the way Obsidian matches a\n   * code block processor's language. Only the sections holding such a block are rendered again, and a view holding none\n   * is left alone.\n   *\n   * @default `null`, which renders every section of every Reading view again\n   */\n  readonly language?: null | string;\n}\n\n/**\n * Get the full HTML content of the current MarkdownView\n *\n * @param view - The MarkdownView to get the HTML from\n * @returns The full HTML of the MarkdownView\n */\nexport function getFullContentHtml(view: MarkdownView): string {\n  const codeMirror = view.editor.cm;\n  codeMirror.viewState.printing = true;\n  codeMirror.measure();\n  const html = view.contentEl.innerHTML;\n  codeMirror.viewState.printing = false;\n  codeMirror.measure();\n  return html;\n}\n\n/**\n * Renders the open Reading views again, so a markdown post-processor or code block processor registered or reconfigured\n * since they rendered applies to them.\n *\n * It covers every Markdown view in every window, popouts included. A full refresh is what Obsidian itself does when a\n * post-processor is registered: every section is rendered again, except the header holding the inline title and the\n * properties, and the footer holding the backlinks, which keep their DOM. With a `language`, only the sections holding a\n * code block of that language are rendered again. The note is never written, the view mode never changes, and the\n * scroll position is kept by Obsidian's renderer.\n *\n * The promise settles once every view SHOWN in Reading view has finished rendering, the promises of asynchronous\n * post-processors included. A preview that is not shown (a background tab, a view in editing mode) is marked to render\n * again when it is next shown, and is not waited for, since Obsidian does not render it until then. A view that is closed,\n * hidden or switched out of Reading view while rendering stops being waited for. A post-processor whose promise never\n * settles, or rejects, keeps its view's render open, exactly as it keeps Obsidian's own render open; pass an\n * `abortSignal` to bound the wait.\n *\n * Hover popovers, embeds, canvas cards and Live Preview widgets are not refreshed.\n *\n * @param params - The options.\n * @returns A promise that resolves once the shown Reading views have rendered.\n */\nexport async function rerenderPreviews(params: RerenderPreviewsParams): Promise<void> {\n  const { abortSignal, app, language = null } = params;\n  abortSignal?.throwIfAborted();\n\n  const views: MarkdownView[] = [];\n  app.workspace.iterateAllLeaves((leaf) => {\n    if (leaf.view instanceof MarkdownView) {\n      views.push(leaf.view);\n    }\n  });\n\n  const waits: Promise<void>[] = [];\n  for (const view of views) {\n    const isShown = isPreviewShown(view);\n    // Emptying the sections shrinks the content before the next frame renders it again, which can clamp the scroll.\n    const scroll = isShown ? view.previewMode.getScroll() : null;\n    if (language === null) {\n      view.previewMode.rerender(true);\n    } else {\n      const sections = getSectionsWithLanguage(view.previewMode, language);\n      if (sections.length === 0) {\n        continue;\n      }\n      rerenderSections(view.previewMode, sections);\n    }\n\n    if (scroll !== null) {\n      waits.push(waitForPreviewRender(app, view, scroll));\n    }\n  }\n\n  if (waits.length === 0) {\n    return;\n  }\n\n  const allRendered = Promise.all(waits);\n  if (!abortSignal) {\n    await allRendered;\n    return;\n  }\n\n  let resolveAborted = noop;\n  const aborted = new Promise<void>((resolve) => {\n    resolveAborted = resolve;\n  });\n  using _abortListener = onAbort(abortSignal, () => {\n    resolveAborted();\n  });\n  await Promise.race([allRendered, aborted]);\n  abortSignal.throwIfAborted();\n}\n\nfunction getSectionsWithLanguage(previewMode: MarkdownPreviewView, language: string): RendererSection[] {\n  const { renderer } = previewMode;\n  const selector = `code.language-${CSS.escape(language)}`;\n  const parser = new DOMParser();\n  // The header and footer carry no HTML of their own. A section's HTML is parsed into an inert document: nothing runs\n  // and nothing loads.\n  return renderer.sections.filter((section) =>\n    section !== renderer.header && section !== renderer.footer && !!section.html\n    && parser.parseFromString(section.html, 'text/html').querySelector(selector) !== null\n  );\n}\n\nfunction isPreviewShown(view: MarkdownView): boolean {\n  if (view.getMode() !== 'preview') {\n    return false;\n  }\n\n  // The same visibility test `ReadViewRenderer.onRender` makes before it renders anything.\n  const { previewEl } = view.previewMode.renderer;\n  return previewEl.isConnected && previewEl.offsetParent !== null && previewEl.offsetWidth > 0;\n}\n\nfunction rerenderSections(previewMode: MarkdownPreviewView, sections: readonly RendererSection[]): void {\n  for (const section of sections) {\n    section.rendered = false;\n    section.el.empty();\n  }\n  previewMode.renderer.queueRender();\n}\n\nasync function waitForPreviewRender(app: App, view: MarkdownView, scroll: number): Promise<void> {\n  const { previewMode } = view;\n  const isRendered = await new Promise<boolean>((resolve) => {\n    let isSettled = false;\n    const watcher = new Component();\n\n    function settle(isRenderedNow: boolean): void {\n      if (isSettled) {\n        return;\n      }\n      isSettled = true;\n      // A no-op when the preview is unloading, since it has already taken the watcher off its children.\n      previewMode.removeChild(watcher);\n      resolve(isRenderedNow);\n    }\n\n    function settleIfHidden(): void {\n      if (!isPreviewShown(view)) {\n        settle(false);\n      }\n    }\n\n    watcher.register(() => {\n      settle(false);\n    });\n    watcher.registerEvent(app.workspace.on('layout-change', settleIfHidden));\n    watcher.registerEvent(app.workspace.on('active-leaf-change', settleIfHidden));\n    previewMode.addChild(watcher);\n    previewMode.renderer.onRendered(() => {\n      settle(true);\n    });\n  });\n\n  if (isRendered) {\n    previewMode.applyScroll(scroll);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/modals/copy-text-manually.d.mts

@@ -0,0 +1,38 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * A modal that shows a text for the user to copy by hand, for when writing it to the clipboard failed.
+ */
+import type { ModalParamsBase } from './modal.mjs';
+/**
+ * Parameters for {@link copyTextManually}.
+ */
+export interface CopyTextManuallyParams extends ModalParamsBase {
+    /**
+     * What the user is asked to do with the text.
+     */
+    readonly message: string;
+    /**
+     * A text for the button that continues.
+     */
+    readonly okButtonText?: string;
+    /**
+     * The text to copy.
+     */
+    readonly text: string;
+    /**
+     * A title of the modal.
+     *
+     * @default `''`
+     */
+    readonly title?: string;
+}
+/**
+ * Shows a read-only text, selected when focused, for the user to copy by hand, with a button that
+ * continues and one that cancels.
+ *
+ * @param params - The parameters.
+ * @returns A {@link Promise} that resolves with whether the user continued.
+ */
+export declare function copyTextManually(params: CopyTextManuallyParams): Promise<boolean>;

package/dist/lib/esm/modals/copy-text-manually.mjs

@@ -0,0 +1,99 @@
+/*
+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 {
+  ButtonComponent,
+  TextAreaComponent
+} from "obsidian";
+import { CssClass } from "../css-class.mjs";
+import { t } from "../i18n/i18n.mjs";
+import {
+  ModalBase,
+  showModal
+} from "./modal.mjs";
+const TEXT_AREA_ROWS = 12;
+class CopyTextManuallyModal extends ModalBase {
+  isConfirmed = false;
+  message;
+  okButtonText;
+  text;
+  title;
+  constructor(params) {
+    super(params);
+    this.addCssClasses(CssClass.CopyTextManuallyModal);
+    this.message = params.message;
+    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianLib.buttons.ok);
+    this.text = params.text;
+    this.title = params.title ?? "";
+  }
+  onClose() {
+    this.promiseResolve(this.isConfirmed);
+  }
+  onOpen() {
+    this.titleEl.setText(this.title);
+    this.contentEl.createEl("p", { text: this.message });
+    const textArea = new TextAreaComponent(this.contentEl);
+    textArea.setValue(this.text);
+    textArea.inputEl.readOnly = true;
+    textArea.inputEl.rows = TEXT_AREA_ROWS;
+    textArea.inputEl.addClass(CssClass.CopyTextManuallyText);
+    textArea.inputEl.addEventListener("focus", () => {
+      textArea.inputEl.select();
+    });
+    const buttonContainerEl = this.contentEl.createDiv({ cls: "modal-button-container" });
+    const okButton = new ButtonComponent(buttonContainerEl);
+    okButton.setButtonText(this.okButtonText);
+    okButton.setCta();
+    okButton.onClick(() => {
+      this.isConfirmed = true;
+      this.close();
+    });
+    okButton.setClass(CssClass.OkButton);
+    const cancelButton = new ButtonComponent(buttonContainerEl);
+    cancelButton.setButtonText(t(($) => $.obsidianLib.buttons.cancel));
+    cancelButton.onClick(this.close.bind(this));
+    cancelButton.setClass(CssClass.CancelButton);
+    textArea.inputEl.focus();
+  }
+}
+async function copyTextManually(params) {
+  return await showModal(
+    (promiseResolve) => new CopyTextManuallyModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+export {
+  copyTextManually
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/modals/index.d.mts

@@ -2,10 +2,12 @@
 export * as 'alert' from './alert.mjs';
 export * as 'code-block-builder' from './code-block-builder.mjs';
 export * as 'confirm' from './confirm.mjs';
+export * as 'copy-text-manually' from './copy-text-manually.mjs';
 export * as 'minimizable-modal' from './minimizable-modal.mjs';
 export * as 'modal-command-builder' from './modal-command-builder.mjs';
 export * as 'modal' from './modal.mjs';
 export * as 'prompt' from './prompt.mjs';
+export * as 'review-bug-report-diagnostics' from './review-bug-report-diagnostics.mjs';
 export * as 'select-item' from './select-item.mjs';
 export * as 'select-option' from './select-option.mjs';
 export * as 'suggest-modal-command-builder' from './suggest-modal-command-builder.mjs';

package/dist/lib/esm/modals/index.mjs

@@ -6,10 +6,12 @@ if you want to view the source, please visit the github repository of this plugi
 import * as alert from "./alert.mjs";
 import * as code_block_builder from "./code-block-builder.mjs";
 import * as confirm from "./confirm.mjs";
+import * as copy_text_manually from "./copy-text-manually.mjs";
 import * as minimizable_modal from "./minimizable-modal.mjs";
 import * as modal_command_builder from "./modal-command-builder.mjs";
 import * as modal from "./modal.mjs";
 import * as prompt from "./prompt.mjs";
+import * as review_bug_report_diagnostics from "./review-bug-report-diagnostics.mjs";
 import * as select_item from "./select-item.mjs";
 import * as select_option from "./select-option.mjs";
 import * as suggest_modal_command_builder from "./suggest-modal-command-builder.mjs";
@@ -17,12 +19,14 @@ export {
   alert,
   code_block_builder as "code-block-builder",
   confirm,
+  copy_text_manually as "copy-text-manually",
   minimizable_modal as "minimizable-modal",
   modal,
   modal_command_builder as "modal-command-builder",
   prompt,
+  review_bug_report_diagnostics as "review-bug-report-diagnostics",
   select_item as "select-item",
   select_option as "select-option",
   suggest_modal_command_builder as "suggest-modal-command-builder"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL21vZGFscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdhbGVydCcgZnJvbSAnLi9hbGVydC50cyc7XG5leHBvcnQgKiBhcyAnY29kZS1ibG9jay1idWlsZGVyJyBmcm9tICcuL2NvZGUtYmxvY2stYnVpbGRlci50cyc7XG5leHBvcnQgKiBhcyAnY29uZmlybScgZnJvbSAnLi9jb25maXJtLnRzJztcbmV4cG9ydCAqIGFzICdtaW5pbWl6YWJsZS1tb2RhbCcgZnJvbSAnLi9taW5pbWl6YWJsZS1tb2RhbC50cyc7XG5leHBvcnQgKiBhcyAnbW9kYWwtY29tbWFuZC1idWlsZGVyJyBmcm9tICcuL21vZGFsLWNvbW1hbmQtYnVpbGRlci50cyc7XG5leHBvcnQgKiBhcyAnbW9kYWwnIGZyb20gJy4vbW9kYWwudHMnO1xuZXhwb3J0ICogYXMgJ3Byb21wdCcgZnJvbSAnLi9wcm9tcHQudHMnO1xuZXhwb3J0ICogYXMgJ3NlbGVjdC1pdGVtJyBmcm9tICcuL3NlbGVjdC1pdGVtLnRzJztcbmV4cG9ydCAqIGFzICdzZWxlY3Qtb3B0aW9uJyBmcm9tICcuL3NlbGVjdC1vcHRpb24udHMnO1xuZXhwb3J0ICogYXMgJ3N1Z2dlc3QtbW9kYWwtY29tbWFuZC1idWlsZGVyJyBmcm9tICcuL3N1Z2dlc3QtbW9kYWwtY29tbWFuZC1idWlsZGVyLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWSxXQUFhO0FBQ3pCLFlBQVlBLHdCQUEwQjtBQUN0QyxZQUFZLGFBQWU7QUFDM0IsWUFBWUMsdUJBQXlCO0FBQ3JDLFlBQVlDLDJCQUE2QjtBQUN6QyxZQUFZLFdBQWE7QUFDekIsWUFBWSxZQUFjO0FBQzFCLFlBQVlDLGlCQUFtQjtBQUMvQixZQUFZQyxtQkFBcUI7QUFDakMsWUFBWUMsbUNBQXFDOyIsCiAgIm5hbWVzIjogWyJjb2RlLWJsb2NrLWJ1aWxkZXIiLCAibWluaW1pemFibGUtbW9kYWwiLCAibW9kYWwtY29tbWFuZC1idWlsZGVyIiwgInNlbGVjdC1pdGVtIiwgInNlbGVjdC1vcHRpb24iLCAic3VnZ2VzdC1tb2RhbC1jb21tYW5kLWJ1aWxkZXIiXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL21vZGFscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdhbGVydCcgZnJvbSAnLi9hbGVydC50cyc7XG5leHBvcnQgKiBhcyAnY29kZS1ibG9jay1idWlsZGVyJyBmcm9tICcuL2NvZGUtYmxvY2stYnVpbGRlci50cyc7XG5leHBvcnQgKiBhcyAnY29uZmlybScgZnJvbSAnLi9jb25maXJtLnRzJztcbmV4cG9ydCAqIGFzICdjb3B5LXRleHQtbWFudWFsbHknIGZyb20gJy4vY29weS10ZXh0LW1hbnVhbGx5LnRzJztcbmV4cG9ydCAqIGFzICdtaW5pbWl6YWJsZS1tb2RhbCcgZnJvbSAnLi9taW5pbWl6YWJsZS1tb2RhbC50cyc7XG5leHBvcnQgKiBhcyAnbW9kYWwtY29tbWFuZC1idWlsZGVyJyBmcm9tICcuL21vZGFsLWNvbW1hbmQtYnVpbGRlci50cyc7XG5leHBvcnQgKiBhcyAnbW9kYWwnIGZyb20gJy4vbW9kYWwudHMnO1xuZXhwb3J0ICogYXMgJ3Byb21wdCcgZnJvbSAnLi9wcm9tcHQudHMnO1xuZXhwb3J0ICogYXMgJ3Jldmlldy1idWctcmVwb3J0LWRpYWdub3N0aWNzJyBmcm9tICcuL3Jldmlldy1idWctcmVwb3J0LWRpYWdub3N0aWNzLnRzJztcbmV4cG9ydCAqIGFzICdzZWxlY3QtaXRlbScgZnJvbSAnLi9zZWxlY3QtaXRlbS50cyc7XG5leHBvcnQgKiBhcyAnc2VsZWN0LW9wdGlvbicgZnJvbSAnLi9zZWxlY3Qtb3B0aW9uLnRzJztcbmV4cG9ydCAqIGFzICdzdWdnZXN0LW1vZGFsLWNvbW1hbmQtYnVpbGRlcicgZnJvbSAnLi9zdWdnZXN0LW1vZGFsLWNvbW1hbmQtYnVpbGRlci50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVksV0FBYTtBQUN6QixZQUFZQSx3QkFBMEI7QUFDdEMsWUFBWSxhQUFlO0FBQzNCLFlBQVlDLHdCQUEwQjtBQUN0QyxZQUFZQyx1QkFBeUI7QUFDckMsWUFBWUMsMkJBQTZCO0FBQ3pDLFlBQVksV0FBYTtBQUN6QixZQUFZLFlBQWM7QUFDMUIsWUFBWUMsbUNBQXFDO0FBQ2pELFlBQVlDLGlCQUFtQjtBQUMvQixZQUFZQyxtQkFBcUI7QUFDakMsWUFBWUMsbUNBQXFDOyIsCiAgIm5hbWVzIjogWyJjb2RlLWJsb2NrLWJ1aWxkZXIiLCAiY29weS10ZXh0LW1hbnVhbGx5IiwgIm1pbmltaXphYmxlLW1vZGFsIiwgIm1vZGFsLWNvbW1hbmQtYnVpbGRlciIsICJyZXZpZXctYnVnLXJlcG9ydC1kaWFnbm9zdGljcyIsICJzZWxlY3QtaXRlbSIsICJzZWxlY3Qtb3B0aW9uIiwgInN1Z2dlc3QtbW9kYWwtY29tbWFuZC1idWlsZGVyIl0KfQo=

package/dist/lib/esm/modals/review-bug-report-diagnostics.d.mts

@@ -0,0 +1,30 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * A modal where the user reviews, and chooses, the diagnostics a bug report will carry, before anything
+ * leaves Obsidian.
+ */
+import type { BugReportDiagnosticSection } from '../bug-report-diagnostics.mjs';
+import type { ModalParamsBase } from './modal.mjs';
+/**
+ * Parameters for {@link reviewBugReportDiagnostics}.
+ */
+export interface ReviewBugReportDiagnosticsParams extends ModalParamsBase {
+    /**
+     * The text the report always carries, shown first in the preview, such as the formatted environment.
+     */
+    readonly alwaysIncludedText?: string;
+    /**
+     * The sections the user may include. A potentially private section starts excluded.
+     */
+    readonly sections: readonly BugReportDiagnosticSection[];
+}
+/**
+ * Shows the user the diagnostics a bug report can carry, with a switch per section and a preview of the
+ * exact text, and lets them continue or cancel. A potentially private section starts switched off.
+ *
+ * @param params - The parameters.
+ * @returns The sections the user chose, in their original order, or `null` when the user cancelled.
+ */
+export declare function reviewBugReportDiagnostics(params: ReviewBugReportDiagnosticsParams): Promise<null | readonly BugReportDiagnosticSection[]>;

package/dist/lib/esm/modals/review-bug-report-diagnostics.mjs

@@ -0,0 +1,120 @@
+/*
+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 {
+  ButtonComponent,
+  Setting
+} from "obsidian";
+import { formatBugReportDiagnostics } from "../bug-report-diagnostics.mjs";
+import { CssClass } from "../css-class.mjs";
+import { t } from "../i18n/i18n.mjs";
+import {
+  ModalBase,
+  showModal
+} from "./modal.mjs";
+class ReviewBugReportDiagnosticsModal extends ModalBase {
+  alwaysIncludedText;
+  includedSectionIds = /* @__PURE__ */ new Set();
+  isContinued = false;
+  previewEl = null;
+  sections;
+  constructor(params) {
+    super(params);
+    this.addCssClasses(CssClass.BugReportReviewModal);
+    this.alwaysIncludedText = params.alwaysIncludedText ?? "";
+    this.sections = params.sections;
+    for (const section of this.sections) {
+      if (!section.isPotentiallyPrivate) {
+        this.includedSectionIds.add(section.id);
+      }
+    }
+  }
+  onClose() {
+    this.promiseResolve(this.isContinued ? this.getIncludedSections() : null);
+  }
+  onOpen() {
+    this.titleEl.setText(t(($) => $.obsidianLib.bugReport.reviewTitle));
+    this.contentEl.createEl("p", { text: t(($) => $.obsidianLib.bugReport.reviewMessage) });
+    for (const section of this.sections) {
+      const setting = new Setting(this.contentEl).setName(section.title).addToggle((toggle) => {
+        toggle.setValue(this.includedSectionIds.has(section.id));
+        toggle.onChange((value) => {
+          if (value) {
+            this.includedSectionIds.add(section.id);
+          } else {
+            this.includedSectionIds.delete(section.id);
+          }
+          this.updatePreview();
+        });
+      });
+      if (section.isPotentiallyPrivate) {
+        setting.setDesc(t(($) => $.obsidianLib.bugReport.potentiallyPrivate));
+      }
+    }
+    this.contentEl.createEl("p", { text: t(($) => $.obsidianLib.bugReport.previewHeading) });
+    this.previewEl = this.contentEl.createEl("pre", { cls: CssClass.BugReportPreview });
+    this.updatePreview();
+    const buttonContainerEl = this.contentEl.createDiv({ cls: "modal-button-container" });
+    const continueButton = new ButtonComponent(buttonContainerEl);
+    continueButton.setButtonText(t(($) => $.obsidianLib.bugReport.continue));
+    continueButton.setCta();
+    continueButton.onClick(() => {
+      this.isContinued = true;
+      this.close();
+    });
+    continueButton.setClass(CssClass.OkButton);
+    const cancelButton = new ButtonComponent(buttonContainerEl);
+    cancelButton.setButtonText(t(($) => $.obsidianLib.buttons.cancel));
+    cancelButton.onClick(this.close.bind(this));
+    cancelButton.setClass(CssClass.CancelButton);
+  }
+  getIncludedSections() {
+    return this.sections.filter((section) => this.includedSectionIds.has(section.id));
+  }
+  updatePreview() {
+    const diagnostics = formatBugReportDiagnostics(this.getIncludedSections());
+    const parts = [this.alwaysIncludedText, diagnostics].filter((part) => part !== "");
+    this.previewEl?.setText(parts.join("\n\n"));
+  }
+}
+async function reviewBugReportDiagnostics(params) {
+  return await showModal(
+    (promiseResolve) => new ReviewBugReportDiagnosticsModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+export {
+  reviewBugReportDiagnostics
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/modals/review-bug-report-diagnostics.ts"],"sourcesContent":["/**\n * @file\n *\n * A modal where the user reviews, and chooses, the diagnostics a bug report will carry, before anything\n * leaves Obsidian.\n */\n\nimport {\n  ButtonComponent,\n  Setting\n} from 'obsidian';\n\nimport type { BugReportDiagnosticSection } from '../bug-report-diagnostics.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport { formatBugReportDiagnostics } from '../bug-report-diagnostics.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport {\n  ModalBase,\n  showModal\n} from './modal.ts';\n\n/**\n * Parameters for {@link reviewBugReportDiagnostics}.\n */\nexport interface ReviewBugReportDiagnosticsParams extends ModalParamsBase {\n  /**\n   * The text the report always carries, shown first in the preview, such as the formatted environment.\n   */\n  readonly alwaysIncludedText?: string;\n\n  /**\n   * The sections the user may include. A potentially private section starts excluded.\n   */\n  readonly sections: readonly BugReportDiagnosticSection[];\n}\n\ntype ReviewBugReportDiagnosticsModalConstructorParams =\n  & ModalBaseConstructorParams<null | readonly BugReportDiagnosticSection[]>\n  & ReviewBugReportDiagnosticsParams;\n\nclass ReviewBugReportDiagnosticsModal extends ModalBase<null | readonly BugReportDiagnosticSection[]> {\n  private readonly alwaysIncludedText: string;\n  private readonly includedSectionIds = new Set<string>();\n  private isContinued = false;\n  private previewEl: HTMLElement | null = null;\n  private readonly sections: readonly BugReportDiagnosticSection[];\n\n  public constructor(params: ReviewBugReportDiagnosticsModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.BugReportReviewModal);\n    this.alwaysIncludedText = params.alwaysIncludedText ?? '';\n    this.sections = params.sections;\n    for (const section of this.sections) {\n      if (!section.isPotentiallyPrivate) {\n        this.includedSectionIds.add(section.id);\n      }\n    }\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.isContinued ? this.getIncludedSections() : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(t(($) => $.obsidianLib.bugReport.reviewTitle));\n    this.contentEl.createEl('p', { text: t(($) => $.obsidianLib.bugReport.reviewMessage) });\n\n    for (const section of this.sections) {\n      const setting = new Setting(this.contentEl)\n        .setName(section.title)\n        .addToggle((toggle) => {\n          toggle.setValue(this.includedSectionIds.has(section.id));\n          toggle.onChange((value) => {\n            if (value) {\n              this.includedSectionIds.add(section.id);\n            } else {\n              this.includedSectionIds.delete(section.id);\n            }\n            this.updatePreview();\n          });\n        });\n      if (section.isPotentiallyPrivate) {\n        setting.setDesc(t(($) => $.obsidianLib.bugReport.potentiallyPrivate));\n      }\n    }\n\n    this.contentEl.createEl('p', { text: t(($) => $.obsidianLib.bugReport.previewHeading) });\n    this.previewEl = this.contentEl.createEl('pre', { cls: CssClass.BugReportPreview });\n    this.updatePreview();\n\n    const buttonContainerEl = this.contentEl.createDiv({ cls: 'modal-button-container' });\n    const continueButton = new ButtonComponent(buttonContainerEl);\n    continueButton.setButtonText(t(($) => $.obsidianLib.bugReport.continue));\n    continueButton.setCta();\n    continueButton.onClick(() => {\n      this.isContinued = true;\n      this.close();\n    });\n    continueButton.setClass(CssClass.OkButton);\n\n    const cancelButton = new ButtonComponent(buttonContainerEl);\n    cancelButton.setButtonText(t(($) => $.obsidianLib.buttons.cancel));\n    cancelButton.onClick(this.close.bind(this));\n    cancelButton.setClass(CssClass.CancelButton);\n  }\n\n  private getIncludedSections(): readonly BugReportDiagnosticSection[] {\n    return this.sections.filter((section) => this.includedSectionIds.has(section.id));\n  }\n\n  private updatePreview(): void {\n    const diagnostics = formatBugReportDiagnostics(this.getIncludedSections());\n    const parts = [this.alwaysIncludedText, diagnostics].filter((part) => part !== '');\n    this.previewEl?.setText(parts.join('\\n\\n'));\n  }\n}\n\n/**\n * Shows the user the diagnostics a bug report can carry, with a switch per section and a preview of the\n * exact text, and lets them continue or cancel. A potentially private section starts switched off.\n *\n * @param params - The parameters.\n * @returns The sections the user chose, in their original order, or `null` when the user cancelled.\n */\nexport async function reviewBugReportDiagnostics(params: ReviewBugReportDiagnosticsParams): Promise<null | readonly BugReportDiagnosticSection[]> {\n  return await showModal<null | readonly BugReportDiagnosticSection[]>((promiseResolve) =>\n    new ReviewBugReportDiagnosticsModal({\n      ...params,\n      promiseResolve\n    })\n  );\n}\n"],"mappings":"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","names":[]}