@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/esm/misplaced-attachment.mjs

@@ -0,0 +1,212 @@
+/*
+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 {
+  getDataAdapterEx,
+  parentFolderPath
+} from "@obsidian-typings/obsidian-public-latest/implementations";
+import {
+  AttachmentPathContext,
+  getAttachmentFolderPathForAttachment
+} from "./attachment-path.mjs";
+import { isNote } from "./file-system.mjs";
+var ExternalAttachmentLinkMode = /* @__PURE__ */ ((ExternalAttachmentLinkMode2) => {
+  ExternalAttachmentLinkMode2["Ignore"] = "Ignore";
+  ExternalAttachmentLinkMode2["Report"] = "Report";
+  ExternalAttachmentLinkMode2["ReportUnowned"] = "ReportUnowned";
+  return ExternalAttachmentLinkMode2;
+})(ExternalAttachmentLinkMode || {});
+class MisplacedAttachmentIndex extends Map {
+  /**
+   * Creates an empty index.
+   *
+   * @param mode - Which external references {@link MisplacedAttachmentIndex.getReported} returns.
+   */
+  constructor(mode = "Report" /* Report */) {
+    super();
+    this.mode = mode;
+  }
+  mode;
+  properNotePathsByAttachment = /* @__PURE__ */ new Map();
+  userNotePathsByAttachment = /* @__PURE__ */ new Map();
+  /**
+   * Records a reference to an attachment outside the referencing note's folder.
+   *
+   * @param notePath - The referencing note's vault-relative path.
+   * @param entry - The reference and the folder the note wants the attachment in.
+   */
+  add(notePath, entry) {
+    let entries = this.get(notePath);
+    if (!entries) {
+      entries = [];
+      this.set(notePath, entries);
+    }
+    entries.push(entry);
+    this.addUser(entry.attachmentPath, notePath);
+  }
+  /**
+   * Records that a note references an attachment, wherever the attachment sits.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The referencing note's vault-relative path.
+   */
+  addUser(attachmentPath, notePath) {
+    addToSetMap(this.userNotePathsByAttachment, attachmentPath, notePath);
+  }
+  /**
+   * The notes that use an attachment besides the given one, its proper notes first, each group in walk order.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The note to leave out: the one whose reference is being reported.
+   * @returns The other notes' paths.
+   */
+  getOtherUserNotePaths(attachmentPath, notePath) {
+    const properNotePaths = this.getProperNotePaths(attachmentPath);
+    const userNotePaths = [...this.userNotePathsByAttachment.get(attachmentPath) ?? []];
+    return [...properNotePaths, ...userNotePaths.filter((path) => !properNotePaths.includes(path))].filter((path) => path !== notePath);
+  }
+  /**
+   * The proper notes of an attachment: the notes that reference it and whose own folder holds it, in walk order.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @returns The proper notes' paths, empty when the attachment has none.
+   */
+  getProperNotePaths(attachmentPath) {
+    return [...this.properNotePathsByAttachment.get(attachmentPath) ?? []];
+  }
+  /**
+   * The entries to report, after the mode is applied, grouped by note, with a note left out once none of its
+   * entries survive.
+   *
+   * @returns The entries to report.
+   */
+  getReported() {
+    const reported = /* @__PURE__ */ new Map();
+    if (this.mode === "Ignore" /* Ignore */) {
+      return reported;
+    }
+    for (const [notePath, entries] of this) {
+      const surviving = this.mode === "ReportUnowned" /* ReportUnowned */ ? entries.filter((entry) => !this.properNotePathsByAttachment.has(entry.attachmentPath)) : entries;
+      if (surviving.length > 0) {
+        reported.set(notePath, surviving);
+      }
+    }
+    return reported;
+  }
+  /**
+   * Whether a note is a proper note of an attachment: it references it, and its own folder holds it.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The note's vault-relative path.
+   * @returns `true` when the note's own attachment folder holds the attachment.
+   */
+  isProperNote(attachmentPath, notePath) {
+    return this.properNotePathsByAttachment.get(attachmentPath)?.has(notePath) ?? false;
+  }
+  /**
+   * Records that an attachment sits in the folder configured for a note that references it, which makes that
+   * note its proper note.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The referencing note whose folder holds it.
+   */
+  markHomed(attachmentPath, notePath) {
+    addToSetMap(this.properNotePathsByAttachment, attachmentPath, notePath);
+    this.addUser(attachmentPath, notePath);
+  }
+}
+async function getAttachmentPlacement(params) {
+  const { app, attachmentFile, notePath } = params;
+  const properAttachmentFolderPath = await getAttachmentFolderPathForAttachment({
+    app,
+    attachmentPathOrFile: attachmentFile,
+    context: AttachmentPathContext.Unknown,
+    notePathOrFile: notePath
+  });
+  const isInsensitive = getDataAdapterEx(app).insensitive;
+  return {
+    isInProperFolder: fold(parentFolderPath(attachmentFile.path)) === fold(properAttachmentFolderPath),
+    properAttachmentFolderPath
+  };
+  function fold(value) {
+    return isInsensitive ? value.toLowerCase() : value;
+  }
+}
+async function recordAttachmentPlacement(params) {
+  const {
+    app,
+    attachmentFile,
+    index,
+    isPathIgnored = isNone,
+    isSharedAttachmentPath = isNone,
+    isTreatedAsAttachment = isNone,
+    notePath,
+    reference
+  } = params;
+  if (index.mode === "Ignore" /* Ignore */) {
+    return;
+  }
+  if (isNote(attachmentFile) && !isTreatedAsAttachment(attachmentFile.path)) {
+    return;
+  }
+  if (isPathIgnored(attachmentFile.path) || isSharedAttachmentPath(attachmentFile.path)) {
+    return;
+  }
+  const placement = await getAttachmentPlacement({ app, attachmentFile, notePath });
+  if (placement.isInProperFolder) {
+    index.markHomed(attachmentFile.path, notePath);
+    return;
+  }
+  index.add(notePath, {
+    attachmentPath: attachmentFile.path,
+    properAttachmentFolderPath: placement.properAttachmentFolderPath,
+    reference
+  });
+}
+function addToSetMap(map, key, value) {
+  let set = map.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key, set);
+  }
+  set.add(value);
+}
+function isNone() {
+  return false;
+}
+export {
+  ExternalAttachmentLinkMode,
+  MisplacedAttachmentIndex,
+  getAttachmentPlacement,
+  recordAttachmentPlacement
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/misplaced-attachment.ts"],"sourcesContent":["/**\n * @file\n *\n * Whether an attachment sits outside the attachment folder of the notes that use it, and which notes are its\n * proper home.\n *\n * Two things here are easy to get wrong:\n *\n * - **The judgement is about the FOLDER, not the path.** `getAttachmentFilePath` answers about the proper\n *   path, folder and templated base name both, so judging on it raw flags every attachment whose NAME does not\n *   match a rename template. That is a different defect. So the comparison is folder against folder, through\n *   `getAttachmentFolderPathForAttachment`, which also skips the name generation that dominates the cost of\n *   the question when `Custom Attachment Location` answers it.\n * - **The proper folder is asked for the REAL attachment, never a dummy.** A folder template may read the\n *   attachment's own name, extension or stats, so `getAttachmentFolderPath`'s dummy-file route can answer\n *   about a file that does not exist.\n *\n * A reference is judged from the note that makes it: `A.md` linking `B/image.png`, which sits in `B.md`'s folder,\n * is A linking an EXTERNAL attachment, even when B uses it too. Whether such a reference is worth reporting depends\n * on whether the attachment has a proper note anywhere, which is known only after every note has been judged, so\n * {@link MisplacedAttachmentIndex} collects the verdicts and {@link MisplacedAttachmentIndex.getReported} applies\n * the {@link ExternalAttachmentLinkMode} at the end.\n *\n * Rendering is the caller's: this module only judges and collects.\n */\n\nimport type {\n  App,\n  Reference,\n  TFile\n} from 'obsidian';\n\nimport {\n  getDataAdapterEx,\n  parentFolderPath\n} from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport {\n  AttachmentPathContext,\n  getAttachmentFolderPathForAttachment\n} from './attachment-path.ts';\nimport { isNote } from './file-system.ts';\n\n/**\n * Which references to an attachment outside the referencing note's attachment folder are reported.\n */\nexport enum ExternalAttachmentLinkMode {\n  /**\n   * Never report one: nothing is judged at all.\n   */\n  Ignore = 'Ignore',\n\n  /**\n   * Report every such reference, including one to an attachment filed in the folder of another note that\n   * references it too.\n   */\n  Report = 'Report',\n\n  /**\n   * Report such a reference only when no note that references the attachment has it in its own folder.\n   */\n  ReportUnowned = 'ReportUnowned'\n}\n\n/**\n * The folder an attachment sits in, judged against the folder one note's configuration puts its attachments in.\n */\nexport interface AttachmentPlacement {\n  /**\n   * Whether the attachment sits in {@link AttachmentPlacement.properAttachmentFolderPath}, compared the way the\n   * vault's adapter compares names (case-folded on a case-insensitive adapter).\n   */\n  readonly isInProperFolder: boolean;\n\n  /**\n   * The vault-relative folder the note's configuration puts this attachment in, `/` for the vault root.\n   */\n  readonly properAttachmentFolderPath: string;\n}\n\n/**\n * Parameters for {@link getAttachmentPlacement}.\n */\nexport interface GetAttachmentPlacementParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The attachment to judge.\n   */\n  readonly attachmentFile: TFile;\n\n  /**\n   * The vault-relative path of the note whose configuration the attachment is judged against.\n   */\n  readonly notePath: string;\n}\n\n/**\n * One reference to an attachment outside the attachment folder of the note that makes it.\n *\n * The same attachment referenced from two notes is two entries, because the two notes can configure different\n * attachment folders.\n */\nexport interface MisplacedAttachmentEntry {\n  /**\n   * The attachment's current vault-relative path.\n   */\n  readonly attachmentPath: string;\n\n  /**\n   * The vault-relative folder the referencing note's configuration puts the attachment in.\n   */\n  readonly properAttachmentFolderPath: string;\n\n  /**\n   * The reference that reaches the attachment.\n   */\n  readonly reference: Reference;\n}\n\n/**\n * Parameters for {@link recordAttachmentPlacement}.\n */\nexport interface RecordAttachmentPlacementParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The file the reference resolved to. Pass only references that resolved: an unresolved one is a broken link,\n   * not a misplaced attachment.\n   */\n  readonly attachmentFile: TFile;\n\n  /**\n   * The index the verdict is recorded in.\n   */\n  readonly index: MisplacedAttachmentIndex;\n\n  /**\n   * Whether a path is never judged, for example because the user excluded it. Defaults to judging every path.\n   */\n  readonly isPathIgnored?: (path: string) => boolean;\n\n  /**\n   * Whether a path lies in a shared attachment location, which is anybody's folder, so no reference into it is\n   * external. Defaults to no shared location.\n   */\n  readonly isSharedAttachmentPath?: (path: string) => boolean;\n\n  /**\n   * Whether a note is treated as an attachment (an `.excalidraw.md` file, say), and so judged here. Defaults to\n   * no note being one.\n   */\n  readonly isTreatedAsAttachment?: (path: string) => boolean;\n\n  /**\n   * The vault-relative path of the note that makes the reference.\n   */\n  readonly notePath: string;\n\n  /**\n   * The reference, kept in the entry so a report can name its line or frontmatter key.\n   */\n  readonly reference: Reference;\n}\n\n/**\n * The verdicts of a walk over every reference to an attachment, grouped by the note that makes the reference.\n *\n * It keeps every external reference, every note that uses each attachment, and each attachment's proper notes:\n * the notes that reference it and whose own folder holds it. Which entries count as reported depends on the\n * {@link ExternalAttachmentLinkMode} and on the proper notes, which are known only once the whole vault has been\n * walked, so ask {@link MisplacedAttachmentIndex.getReported} after the walk.\n */\nexport class MisplacedAttachmentIndex extends Map<string, MisplacedAttachmentEntry[]> {\n  private readonly properNotePathsByAttachment = new Map<string, Set<string>>();\n  private readonly userNotePathsByAttachment = new Map<string, Set<string>>();\n\n  /**\n   * Creates an empty index.\n   *\n   * @param mode - Which external references {@link MisplacedAttachmentIndex.getReported} returns.\n   */\n  public constructor(public readonly mode = ExternalAttachmentLinkMode.Report) {\n    super();\n  }\n\n  /**\n   * Records a reference to an attachment outside the referencing note's folder.\n   *\n   * @param notePath - The referencing note's vault-relative path.\n   * @param entry - The reference and the folder the note wants the attachment in.\n   */\n  public add(notePath: string, entry: MisplacedAttachmentEntry): void {\n    let entries = this.get(notePath);\n    if (!entries) {\n      entries = [];\n      this.set(notePath, entries);\n    }\n    entries.push(entry);\n    this.addUser(entry.attachmentPath, notePath);\n  }\n\n  /**\n   * Records that a note references an attachment, wherever the attachment sits.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The referencing note's vault-relative path.\n   */\n  public addUser(attachmentPath: string, notePath: string): void {\n    addToSetMap(this.userNotePathsByAttachment, attachmentPath, notePath);\n  }\n\n  /**\n   * The notes that use an attachment besides the given one, its proper notes first, each group in walk order.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The note to leave out: the one whose reference is being reported.\n   * @returns The other notes' paths.\n   */\n  public getOtherUserNotePaths(attachmentPath: string, notePath: string): string[] {\n    const properNotePaths = this.getProperNotePaths(attachmentPath);\n    const userNotePaths = [...this.userNotePathsByAttachment.get(attachmentPath) ?? []];\n    return [...properNotePaths, ...userNotePaths.filter((path) => !properNotePaths.includes(path))].filter((path) => path !== notePath);\n  }\n\n  /**\n   * The proper notes of an attachment: the notes that reference it and whose own folder holds it, in walk order.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @returns The proper notes' paths, empty when the attachment has none.\n   */\n  public getProperNotePaths(attachmentPath: string): string[] {\n    return [...this.properNotePathsByAttachment.get(attachmentPath) ?? []];\n  }\n\n  /**\n   * The entries to report, after the mode is applied, grouped by note, with a note left out once none of its\n   * entries survive.\n   *\n   * @returns The entries to report.\n   */\n  public getReported(): Map<string, MisplacedAttachmentEntry[]> {\n    const reported = new Map<string, MisplacedAttachmentEntry[]>();\n    if (this.mode === ExternalAttachmentLinkMode.Ignore) {\n      return reported;\n    }\n\n    for (const [notePath, entries] of this) {\n      const surviving = this.mode === ExternalAttachmentLinkMode.ReportUnowned\n        ? entries.filter((entry) => !this.properNotePathsByAttachment.has(entry.attachmentPath))\n        : entries;\n      if (surviving.length > 0) {\n        reported.set(notePath, surviving);\n      }\n    }\n    return reported;\n  }\n\n  /**\n   * Whether a note is a proper note of an attachment: it references it, and its own folder holds it.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The note's vault-relative path.\n   * @returns `true` when the note's own attachment folder holds the attachment.\n   */\n  public isProperNote(attachmentPath: string, notePath: string): boolean {\n    return this.properNotePathsByAttachment.get(attachmentPath)?.has(notePath) ?? false;\n  }\n\n  /**\n   * Records that an attachment sits in the folder configured for a note that references it, which makes that\n   * note its proper note.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The referencing note whose folder holds it.\n   */\n  public markHomed(attachmentPath: string, notePath: string): void {\n    addToSetMap(this.properNotePathsByAttachment, attachmentPath, notePath);\n    this.addUser(attachmentPath, notePath);\n  }\n}\n\n/**\n * Judges where an attachment sits against the attachment folder of one note.\n *\n * Asks the attachment-path seam once, folder-only, for the REAL attachment, so a `Custom Attachment Location`\n * folder template that reads the attachment's own name is honoured and no name is generated.\n *\n * @param params - The attachment and the note.\n * @returns The note's proper folder for the attachment, and whether the attachment is in it.\n */\nexport async function getAttachmentPlacement(params: GetAttachmentPlacementParams): Promise<AttachmentPlacement> {\n  const { app, attachmentFile, notePath } = params;\n  const properAttachmentFolderPath = await getAttachmentFolderPathForAttachment({\n    app,\n    attachmentPathOrFile: attachmentFile,\n    context: AttachmentPathContext.Unknown,\n    notePathOrFile: notePath\n  });\n\n  // Fold as `isAtProperAttachmentPath` does, so a case-insensitive adapter does not report a folder that differs\n  // only in case.\n  const isInsensitive = getDataAdapterEx(app).insensitive;\n  return {\n    isInProperFolder: fold(parentFolderPath(attachmentFile.path)) === fold(properAttachmentFolderPath),\n    properAttachmentFolderPath\n  };\n\n  function fold(value: string): string {\n    return isInsensitive ? value.toLowerCase() : value;\n  }\n}\n\n/**\n * Judges one resolved reference and records the verdict in the index.\n *\n * Records nothing under {@link ExternalAttachmentLinkMode.Ignore}, for a note that is not treated as an\n * attachment, and for an ignored or shared path. Otherwise the referencing note becomes a proper note of the\n * attachment when its folder holds it, and the reference becomes an entry when it does not.\n *\n * @param params - The reference, its note, its target and the index.\n * @returns A {@link Promise} that resolves once the verdict is recorded.\n */\nexport async function recordAttachmentPlacement(params: RecordAttachmentPlacementParams): Promise<void> {\n  const {\n    app,\n    attachmentFile,\n    index,\n    isPathIgnored = isNone,\n    isSharedAttachmentPath = isNone,\n    isTreatedAsAttachment = isNone,\n    notePath,\n    reference\n  } = params;\n\n  if (index.mode === ExternalAttachmentLinkMode.Ignore) {\n    return;\n  }\n\n  if (isNote(attachmentFile) && !isTreatedAsAttachment(attachmentFile.path)) {\n    return;\n  }\n\n  if (isPathIgnored(attachmentFile.path) || isSharedAttachmentPath(attachmentFile.path)) {\n    return;\n  }\n\n  const placement = await getAttachmentPlacement({ app, attachmentFile, notePath });\n\n  if (placement.isInProperFolder) {\n    index.markHomed(attachmentFile.path, notePath);\n    return;\n  }\n\n  index.add(notePath, {\n    attachmentPath: attachmentFile.path,\n    properAttachmentFolderPath: placement.properAttachmentFolderPath,\n    reference\n  });\n}\n\nfunction addToSetMap(map: Map<string, Set<string>>, key: string, value: string): void {\n  let set = map.get(key);\n  if (!set) {\n    set = new Set<string>();\n    map.set(key, set);\n  }\n  set.add(value);\n}\n\nfunction isNone(): boolean {\n  return false;\n}\n"],"mappings":"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","names":["ExternalAttachmentLinkMode"]}

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/prompt.d.mts

@@ -73,7 +73,7 @@ export interface PromptParams extends ModalParamsBase {
      * @param value - The input value to validate.
      * @returns an error message if the value is invalid, or `null` if the value is valid.
      */
-    readonly valueValidator?: (value: string) => Promisable<MaybeReturn<string>>;
+    readonly valueValidator?: (value: string) => Promisable<MaybeReturn<null | string>>;
 }
 /**
  * Displays a prompt modal in Obsidian to get user input.

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

@@ -156,4 +156,4 @@ async function prompt(params) {
 export {
   prompt
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/modals/prompt.ts"],"sourcesContent":["/**\n * @file\n *\n * Utility for displaying a prompt modal in Obsidian.\n *\n * This module exports a function to display a modal that prompts the user for input. The modal includes \"OK\" and \"Cancel\" buttons.\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '@mnaoumov/typescript-lib/async';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  ModalCommandBuilder,\n  ModalCommandBuilderBuildOptions,\n  ModalCommandsRenderMode\n} from './modal-command-builder.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport { CssClass } from '../css-class.ts';\nimport { applySpellcheckMode } from '../html-element.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { SpellcheckMode } from '../obsidian-settings.ts';\nimport {\n  ModalBase,\n  showModal\n} from './modal.ts';\n\n/**\n * Options for {@link prompt}.\n */\nexport interface PromptParams extends ModalParamsBase {\n  /**\n   * A text for the \"Cancel\" button.\n   */\n  readonly cancelButtonText?: string;\n\n  /**\n   * Extra controls — checkboxes, dropdowns and keyboard shortcuts — rendered as a strip along the bottom\n   * of the modal, so a caller gets a text input plus options with no bespoke modal of its own.\n   *\n   * Hand it a configured {@link ModalCommandBuilder}; the modal builds it. The strip is rendered after\n   * the buttons, so it sits along the bottom edge where a `SuggestModal`'s instruction bar sits.\n   */\n  readonly commandBuilder?: ModalCommandBuilder;\n\n  /**\n   * The way {@link PromptParams.commandBuilder}'s controls are rendered.\n   *\n   * @default `ModalCommandsRenderMode.Instructions`\n   */\n  readonly commandsRenderMode?: ModalCommandsRenderMode;\n\n  /**\n   * A default value to pre-fill the input field.\n   *\n   * @default `''`\n   */\n  readonly defaultValue?: string;\n\n  /**\n   * A text for the \"OK\" button.\n   */\n  readonly okButtonText?: string;\n\n  /**\n   * A placeholder text for the input field.\n   *\n   * @default `''`\n   */\n  readonly placeholder?: string;\n\n  /**\n   * The mode deciding whether the input is spell-checked.\n   *\n   * The default is what this modal has always done, so passing nothing changes nothing: the input follows\n   * `Editor > Spellcheck`, like Obsidian's own name-entry surfaces. Pass {@link SpellcheckMode.Off} for a\n   * box that is really a search field, or {@link SpellcheckMode.AlwaysOn} to spell-check it whatever the\n   * vault setting says.\n   *\n   * @default `SpellcheckMode.FollowObsidianSetting`\n   */\n  readonly spellcheckMode?: SpellcheckMode;\n\n  /**\n   * A title of the modal.\n   *\n   * @default `''`\n   */\n  readonly title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\n   *\n   * @param value - The input value to validate.\n   * @returns an error message if the value is invalid, or `null` if the value is valid.\n   */\n  readonly valueValidator?: (value: string) => Promisable<MaybeReturn<string>>;\n}\n\ntype PromptModalConstructorParams = ModalBaseConstructorParams<null | string> & PromptParams;\n\nclass PromptModal extends ModalBase<null | string> {\n  private readonly cancelButtonText: string;\n  private readonly commandBuilder: ModalCommandBuilder | null;\n  private readonly commandsRenderMode: ModalCommandsRenderMode | undefined;\n  private isOkClicked = false;\n  private isTouched = false;\n  private readonly okButtonText: string;\n  private readonly placeholder: string;\n  private readonly spellcheckMode: SpellcheckMode;\n  private readonly title: DocumentFragment | string;\n  private value: string;\n  private readonly valueValidator: (value: string) => Promisable<MaybeReturn<string>>;\n\n  public constructor(params: PromptModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.PromptModal);\n    this.cancelButtonText = params.cancelButtonText ?? t(($) => $.obsidianLib.buttons.cancel);\n    this.commandBuilder = params.commandBuilder ?? null;\n    this.commandsRenderMode = params.commandsRenderMode;\n    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianLib.buttons.ok);\n    this.placeholder = params.placeholder ?? '';\n    this.spellcheckMode = params.spellcheckMode ?? SpellcheckMode.FollowObsidianSetting;\n    this.title = params.title ?? '';\n    this.valueValidator = params.valueValidator ?? noop;\n    this.value = params.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.title);\n    const textComponent = new TextComponent(this.contentEl);\n    const inputEl = textComponent.inputEl;\n    // `AbstractTextComponent` forces `spellcheck=\"false\"` on every text component, so the mode has to be applied here.\n    // Obsidian's own file explorer reads the same config when it starts an inline rename.\n    applySpellcheckMode({\n      app: this.app,\n      element: inputEl,\n      spellcheckMode: this.spellcheckMode\n    });\n\n    const validate = async (shouldReport: boolean): Promise<void> => {\n      const errorMessage = await this.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      if (shouldReport) {\n        inputEl.reportValidity();\n      }\n    };\n\n    const handleInput = async (): Promise<void> => {\n      this.markTouched(inputEl);\n      await validate(true);\n    };\n\n    const handleFocus = async (): Promise<void> => {\n      await validate(this.isTouched);\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.inputEl.select();\n    textComponent.setPlaceholder(this.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    // The modal opens invalid by design (see below), so the invalid styling is deferred until touched.\n    inputEl.addClass(CssClass.Untouched);\n    textComponent.onChange((newValue) => {\n      this.value = newValue;\n    });\n    inputEl.addEventListener('keydown', ($event: KeyboardEvent) => {\n      if ($event.key === 'Enter') {\n        this.handleOk($event, textComponent);\n      } else if ($event.key === 'Escape') {\n        this.close();\n      }\n    });\n    inputEl.addEventListener('input', convertAsyncToSync(handleInput));\n    inputEl.addEventListener('focus', convertAsyncToSync(handleFocus));\n    // The modal must start out invalid so OK refuses, but the validity is not reported until the user types or submits.\n    invokeAsyncSafely(() => validate(false));\n    const okButton = new ButtonComponent(this.contentEl);\n    okButton.setButtonText(this.okButtonText);\n    okButton.setCta();\n    okButton.onClick(($event) => {\n      this.handleOk($event, textComponent);\n    });\n    okButton.setClass(CssClass.OkButton);\n    const cancelButton = new ButtonComponent(this.contentEl);\n    cancelButton.setButtonText(this.cancelButtonText);\n    cancelButton.onClick(this.close.bind(this));\n    cancelButton.setClass(CssClass.CancelButton);\n\n    // Built last so the strip lands along the modal's bottom edge, where a `SuggestModal`'s instruction\n    // bar sits.\n    this.commandBuilder?.build(this, normalizeOptionalProperties<ModalCommandBuilderBuildOptions>({ renderMode: this.commandsRenderMode }));\n  }\n\n  private handleOk($event: Event, textComponent: TextComponent): void {\n    $event.preventDefault();\n    if (!textComponent.inputEl.checkValidity()) {\n      this.markTouched(textComponent.inputEl);\n      textComponent.inputEl.reportValidity();\n      return;\n    }\n\n    this.isOkClicked = true;\n    this.close();\n  }\n\n  private markTouched(inputEl: HTMLInputElement): void {\n    this.isTouched = true;\n    inputEl.removeClass(CssClass.Untouched);\n  }\n}\n\n/**\n * Displays a prompt modal in Obsidian to get user input.\n *\n * @param params - The parameters for the prompt modal.\n * @returns A {@link Promise} that resolves with the user input or `null` if the prompt was cancelled.\n */\nexport async function prompt(params: PromptParams): Promise<null | string> {\n  return await showModal<null | string>((promiseResolve) =>\n    new PromptModal({\n      ...params,\n      promiseResolve\n    })\n  );\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/modals/prompt.ts"],"sourcesContent":["/**\n * @file\n *\n * Utility for displaying a prompt modal in Obsidian.\n *\n * This module exports a function to display a modal that prompts the user for input. The modal includes \"OK\" and \"Cancel\" buttons.\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '@mnaoumov/typescript-lib/async';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  ModalCommandBuilder,\n  ModalCommandBuilderBuildOptions,\n  ModalCommandsRenderMode\n} from './modal-command-builder.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport { CssClass } from '../css-class.ts';\nimport { applySpellcheckMode } from '../html-element.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { SpellcheckMode } from '../obsidian-settings.ts';\nimport {\n  ModalBase,\n  showModal\n} from './modal.ts';\n\n/**\n * Options for {@link prompt}.\n */\nexport interface PromptParams extends ModalParamsBase {\n  /**\n   * A text for the \"Cancel\" button.\n   */\n  readonly cancelButtonText?: string;\n\n  /**\n   * Extra controls — checkboxes, dropdowns and keyboard shortcuts — rendered as a strip along the bottom\n   * of the modal, so a caller gets a text input plus options with no bespoke modal of its own.\n   *\n   * Hand it a configured {@link ModalCommandBuilder}; the modal builds it. The strip is rendered after\n   * the buttons, so it sits along the bottom edge where a `SuggestModal`'s instruction bar sits.\n   */\n  readonly commandBuilder?: ModalCommandBuilder;\n\n  /**\n   * The way {@link PromptParams.commandBuilder}'s controls are rendered.\n   *\n   * @default `ModalCommandsRenderMode.Instructions`\n   */\n  readonly commandsRenderMode?: ModalCommandsRenderMode;\n\n  /**\n   * A default value to pre-fill the input field.\n   *\n   * @default `''`\n   */\n  readonly defaultValue?: string;\n\n  /**\n   * A text for the \"OK\" button.\n   */\n  readonly okButtonText?: string;\n\n  /**\n   * A placeholder text for the input field.\n   *\n   * @default `''`\n   */\n  readonly placeholder?: string;\n\n  /**\n   * The mode deciding whether the input is spell-checked.\n   *\n   * The default is what this modal has always done, so passing nothing changes nothing: the input follows\n   * `Editor > Spellcheck`, like Obsidian's own name-entry surfaces. Pass {@link SpellcheckMode.Off} for a\n   * box that is really a search field, or {@link SpellcheckMode.AlwaysOn} to spell-check it whatever the\n   * vault setting says.\n   *\n   * @default `SpellcheckMode.FollowObsidianSetting`\n   */\n  readonly spellcheckMode?: SpellcheckMode;\n\n  /**\n   * A title of the modal.\n   *\n   * @default `''`\n   */\n  readonly title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\n   *\n   * @param value - The input value to validate.\n   * @returns an error message if the value is invalid, or `null` if the value is valid.\n   */\n  readonly valueValidator?: (value: string) => Promisable<MaybeReturn<null | string>>;\n}\n\ntype PromptModalConstructorParams = ModalBaseConstructorParams<null | string> & PromptParams;\n\nclass PromptModal extends ModalBase<null | string> {\n  private readonly cancelButtonText: string;\n  private readonly commandBuilder: ModalCommandBuilder | null;\n  private readonly commandsRenderMode: ModalCommandsRenderMode | undefined;\n  private isOkClicked = false;\n  private isTouched = false;\n  private readonly okButtonText: string;\n  private readonly placeholder: string;\n  private readonly spellcheckMode: SpellcheckMode;\n  private readonly title: DocumentFragment | string;\n  private value: string;\n  private readonly valueValidator: (value: string) => Promisable<MaybeReturn<null | string>>;\n\n  public constructor(params: PromptModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.PromptModal);\n    this.cancelButtonText = params.cancelButtonText ?? t(($) => $.obsidianLib.buttons.cancel);\n    this.commandBuilder = params.commandBuilder ?? null;\n    this.commandsRenderMode = params.commandsRenderMode;\n    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianLib.buttons.ok);\n    this.placeholder = params.placeholder ?? '';\n    this.spellcheckMode = params.spellcheckMode ?? SpellcheckMode.FollowObsidianSetting;\n    this.title = params.title ?? '';\n    this.valueValidator = params.valueValidator ?? noop;\n    this.value = params.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.title);\n    const textComponent = new TextComponent(this.contentEl);\n    const inputEl = textComponent.inputEl;\n    // `AbstractTextComponent` forces `spellcheck=\"false\"` on every text component, so the mode has to be applied here.\n    // Obsidian's own file explorer reads the same config when it starts an inline rename.\n    applySpellcheckMode({\n      app: this.app,\n      element: inputEl,\n      spellcheckMode: this.spellcheckMode\n    });\n\n    const validate = async (shouldReport: boolean): Promise<void> => {\n      const errorMessage = await this.valueValidator(inputEl.value) as null | string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      if (shouldReport) {\n        inputEl.reportValidity();\n      }\n    };\n\n    const handleInput = async (): Promise<void> => {\n      this.markTouched(inputEl);\n      await validate(true);\n    };\n\n    const handleFocus = async (): Promise<void> => {\n      await validate(this.isTouched);\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.inputEl.select();\n    textComponent.setPlaceholder(this.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    // The modal opens invalid by design (see below), so the invalid styling is deferred until touched.\n    inputEl.addClass(CssClass.Untouched);\n    textComponent.onChange((newValue) => {\n      this.value = newValue;\n    });\n    inputEl.addEventListener('keydown', ($event: KeyboardEvent) => {\n      if ($event.key === 'Enter') {\n        this.handleOk($event, textComponent);\n      } else if ($event.key === 'Escape') {\n        this.close();\n      }\n    });\n    inputEl.addEventListener('input', convertAsyncToSync(handleInput));\n    inputEl.addEventListener('focus', convertAsyncToSync(handleFocus));\n    // The modal must start out invalid so OK refuses, but the validity is not reported until the user types or submits.\n    invokeAsyncSafely(() => validate(false));\n    const okButton = new ButtonComponent(this.contentEl);\n    okButton.setButtonText(this.okButtonText);\n    okButton.setCta();\n    okButton.onClick(($event) => {\n      this.handleOk($event, textComponent);\n    });\n    okButton.setClass(CssClass.OkButton);\n    const cancelButton = new ButtonComponent(this.contentEl);\n    cancelButton.setButtonText(this.cancelButtonText);\n    cancelButton.onClick(this.close.bind(this));\n    cancelButton.setClass(CssClass.CancelButton);\n\n    // Built last so the strip lands along the modal's bottom edge, where a `SuggestModal`'s instruction\n    // bar sits.\n    this.commandBuilder?.build(this, normalizeOptionalProperties<ModalCommandBuilderBuildOptions>({ renderMode: this.commandsRenderMode }));\n  }\n\n  private handleOk($event: Event, textComponent: TextComponent): void {\n    $event.preventDefault();\n    if (!textComponent.inputEl.checkValidity()) {\n      this.markTouched(textComponent.inputEl);\n      textComponent.inputEl.reportValidity();\n      return;\n    }\n\n    this.isOkClicked = true;\n    this.close();\n  }\n\n  private markTouched(inputEl: HTMLInputElement): void {\n    this.isTouched = true;\n    inputEl.removeClass(CssClass.Untouched);\n  }\n}\n\n/**\n * Displays a prompt modal in Obsidian to get user input.\n *\n * @param params - The parameters for the prompt modal.\n * @returns A {@link Promise} that resolves with the user input or `null` if the prompt was cancelled.\n */\nexport async function prompt(params: PromptParams): Promise<null | string> {\n  return await showModal<null | string>((promiseResolve) =>\n    new PromptModal({\n      ...params,\n      promiseResolve\n    })\n  );\n}\n"],"mappings":"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","names":[]}

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[]>;