@mnaoumov/obsidian-lib 10.11.0 → 10.12.0

package/dist/lib/cjs/bug-report.cjs

@@ -125,7 +125,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var bug_report_exports = {};
 __export(bug_report_exports, {
   BUG_REPORT_ISSUE_FORM_TEMPLATE: () => BUG_REPORT_ISSUE_FORM_TEMPLATE,
+  BUG_REPORT_PASTE_INSTRUCTIONS: () => BUG_REPORT_PASTE_INSTRUCTIONS,
   BugReportIssueFormFieldId: () => BugReportIssueFormFieldId,
+  DEFAULT_BUG_REPORT_MAX_URL_LENGTH: () => DEFAULT_BUG_REPORT_MAX_URL_LENGTH,
+  buildBugReportIssueFormLink: () => buildBugReportIssueFormLink,
   formatBugReportEnvironment: () => formatBugReportEnvironment,
   getBugReportEnvironment: () => getBugReportEnvironment,
   getBugReportIssueFormUrl: () => getBugReportIssueFormUrl,
@@ -133,6 +136,7 @@ __export(bug_report_exports, {
 });
 module.exports = __toCommonJS(bug_report_exports);
 var import_obsidian = require('obsidian');
+var import_bug_report_diagnostics = require('./bug-report-diagnostics.cjs');
 var import_mobile_app_info = require('./mobile-app-info.cjs');
 var BugReportIssueFormFieldId = /* @__PURE__ */ ((BugReportIssueFormFieldId2) => {
   BugReportIssueFormFieldId2["Environment"] = "environment";
@@ -142,7 +146,31 @@ var BugReportIssueFormFieldId = /* @__PURE__ */ ((BugReportIssueFormFieldId2) =>
   return BugReportIssueFormFieldId2;
 })(BugReportIssueFormFieldId || {});
 const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
+const DEFAULT_BUG_REPORT_MAX_URL_LENGTH = 6e3;
+const BUG_REPORT_PASTE_INSTRUCTIONS = "The full environment and diagnostics were copied to your clipboard because they are too long for a link. Replace this text by pasting them here.";
 const UNKNOWN = "unknown";
+function buildBugReportIssueFormLink(params) {
+  const { environment } = params;
+  const diagnosticsMarkdown = (0, import_bug_report_diagnostics.formatBugReportDiagnostics)(params.diagnostics ?? []);
+  const environmentText = diagnosticsMarkdown === "" ? formatBugReportEnvironment(environment) : `${formatBugReportEnvironment(environment)}
+
+${diagnosticsMarkdown}`;
+  function buildUrl(environmentFieldValue) {
+    return getGitHubIssueFormUrl({
+      fields: {
+        ["environment" /* Environment */]: environmentFieldValue,
+        ["obsidian-version" /* ObsidianVersion */]: environment.obsidianVersion,
+        ["operating-system" /* OperatingSystem */]: environment.operatingSystem,
+        ["plugin-version" /* PluginVersion */]: environment.plugin.version ?? UNKNOWN
+      },
+      gitHubRepo: params.gitHubRepo,
+      template: BUG_REPORT_ISSUE_FORM_TEMPLATE,
+      ...params.title !== void 0 && { title: params.title }
+    });
+  }
+  const fullUrl = buildUrl(environmentText);
+  return fullUrl.length <= (params.maxUrlLength ?? DEFAULT_BUG_REPORT_MAX_URL_LENGTH) ? { clipboardText: null, url: fullUrl } : { clipboardText: environmentText, url: buildUrl(BUG_REPORT_PASTE_INSTRUCTIONS) };
+}
 function formatBugReportEnvironment(environment) {
   const enabledPlugins = environment.enabledPlugins.length === 0 ? "none" : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(", ");
   return `- Plugin: ${formatPluginInfo(environment.plugin)}
@@ -167,17 +195,12 @@ async function getBugReportEnvironment(params) {
 }
 async function getBugReportIssueFormUrl(params) {
   const environment = await getBugReportEnvironment(params);
-  return getGitHubIssueFormUrl({
-    fields: {
-      ["environment" /* Environment */]: formatBugReportEnvironment(environment),
-      ["obsidian-version" /* ObsidianVersion */]: environment.obsidianVersion,
-      ["operating-system" /* OperatingSystem */]: environment.operatingSystem,
-      ["plugin-version" /* PluginVersion */]: environment.plugin.version ?? UNKNOWN
-    },
+  return buildBugReportIssueFormLink({
+    environment,
     gitHubRepo: params.gitHubRepo,
-    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,
+    maxUrlLength: Infinity,
     ...params.title !== void 0 && { title: params.title }
-  });
+  }).url;
 }
 function getGitHubIssueFormUrl(params) {
   const searchParams = new URLSearchParams({ template: params.template });
@@ -234,10 +257,13 @@ function getPluginInfo(app, pluginId) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BUG_REPORT_ISSUE_FORM_TEMPLATE,
+  BUG_REPORT_PASTE_INSTRUCTIONS,
   BugReportIssueFormFieldId,
+  DEFAULT_BUG_REPORT_MAX_URL_LENGTH,
+  buildBugReportIssueFormLink,
   formatBugReportEnvironment,
   getBugReportEnvironment,
   getBugReportIssueFormUrl,
   getGitHubIssueFormUrl
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other loaded plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id\n    // whose folder was deleted, or whose load failed.\n    enabledPlugins: Object.keys(app.plugins.plugins)\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return getGitHubIssueFormUrl({\n    fields: {\n      [BugReportIssueFormFieldId.Environment]: formatBugReportEnvironment(environment),\n      [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n      [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n      [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n    },\n    gitHubRepo: params.gitHubRepo,\n    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n    ...params.title !== undefined && { title: params.title }\n  });\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":"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","names":["BugReportIssueFormFieldId"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport type { BugReportDiagnosticSection } from './bug-report-diagnostics.ts';\n\nimport { formatBugReportDiagnostics } from './bug-report-diagnostics.ts';\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The default budget, in characters of the encoded URL, of a prefilled bug-report link.\n *\n * Measured against `github.com` on 2026-11-07, signed out: an issue-form URL up to about 6,540 characters\n * was answered with the usual redirect to the form, about 8,088 with a 502, and 8,288 and more with a 414.\n * 6,000 leaves room for a longer repository name and for a signed-in session's own limits.\n */\nexport const DEFAULT_BUG_REPORT_MAX_URL_LENGTH = 6000;\n\n/**\n * A link to a bug-report issue form, as {@link buildBugReportIssueFormLink} builds it.\n */\nexport interface BugReportIssueFormLink {\n  /**\n   * The text the user must paste into the form's environment field, when the full report did not fit the\n   * URL budget; `null` when the URL carries the whole report.\n   */\n  readonly clipboardText: null | string;\n\n  /**\n   * The link.\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link buildBugReportIssueFormLink}.\n */\nexport interface BuildBugReportIssueFormLinkParams {\n  /**\n   * The diagnostics the user agreed to include, appended to the environment field.\n   */\n  readonly diagnostics?: readonly BugReportDiagnosticSection[];\n\n  /**\n   * The environment, from {@link getBugReportEnvironment}.\n   */\n  readonly environment: BugReportEnvironment;\n\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The most characters the encoded URL may have before the report moves to the clipboard.\n   *\n   * @default {@link DEFAULT_BUG_REPORT_MAX_URL_LENGTH}\n   */\n  readonly maxUrlLength?: number;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * The text the environment field holds when the report moved to the clipboard.\n */\nexport const BUG_REPORT_PASTE_INSTRUCTIONS = 'The full environment and diagnostics were copied to your clipboard because they are too long for a link. Replace this text by pasting them here.';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other loaded plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Builds a link to a plugin's bug-report issue form, prefilled with the environment and the given\n * diagnostics. When the encoded link would be longer than\n * {@link BuildBugReportIssueFormLinkParams.maxUrlLength}, the environment field gets\n * {@link BUG_REPORT_PASTE_INSTRUCTIONS} instead, and the full text is returned as\n * {@link BugReportIssueFormLink.clipboardText} for the caller to copy. Nothing is cut.\n *\n * @param params - The parameters.\n * @returns The link, and the text to paste when it did not fit.\n */\nexport function buildBugReportIssueFormLink(params: BuildBugReportIssueFormLinkParams): BugReportIssueFormLink {\n  const { environment } = params;\n  const diagnosticsMarkdown = formatBugReportDiagnostics(params.diagnostics ?? []);\n  const environmentText = diagnosticsMarkdown === ''\n    ? formatBugReportEnvironment(environment)\n    : `${formatBugReportEnvironment(environment)}\\n\\n${diagnosticsMarkdown}`;\n\n  function buildUrl(environmentFieldValue: string): string {\n    return getGitHubIssueFormUrl({\n      fields: {\n        [BugReportIssueFormFieldId.Environment]: environmentFieldValue,\n        [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n        [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n        [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n      },\n      gitHubRepo: params.gitHubRepo,\n      template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n      ...params.title !== undefined && { title: params.title }\n    });\n  }\n\n  const fullUrl = buildUrl(environmentText);\n  return fullUrl.length <= (params.maxUrlLength ?? DEFAULT_BUG_REPORT_MAX_URL_LENGTH) ? { clipboardText: null, url: fullUrl } : { clipboardText: environmentText, url: buildUrl(BUG_REPORT_PASTE_INSTRUCTIONS) };\n}\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id\n    // whose folder was deleted, or whose load failed.\n    enabledPlugins: Object.keys(app.plugins.plugins)\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return buildBugReportIssueFormLink({\n    environment,\n    gitHubRepo: params.gitHubRepo,\n    maxUrlLength: Infinity,\n    ...params.title !== undefined && { title: params.title }\n  }).url;\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":"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","names":["BugReportIssueFormFieldId"]}

package/dist/lib/cjs/bug-report.d.cts

@@ -13,6 +13,7 @@
  * structurally here, and reads as `unknown` if a later version drops it.
  */
 import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { BugReportDiagnosticSection } from './bug-report-diagnostics.cjs';
 /**
  * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub
  * prefills a field from a query parameter named after the field's `id`, so a form must give its fields
@@ -40,6 +41,59 @@ export declare enum BugReportIssueFormFieldId {
  * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.
  */
 export declare const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
+/**
+ * The default budget, in characters of the encoded URL, of a prefilled bug-report link.
+ *
+ * Measured against `github.com` on 2026-11-07, signed out: an issue-form URL up to about 6,540 characters
+ * was answered with the usual redirect to the form, about 8,088 with a 502, and 8,288 and more with a 414.
+ * 6,000 leaves room for a longer repository name and for a signed-in session's own limits.
+ */
+export declare const DEFAULT_BUG_REPORT_MAX_URL_LENGTH = 6000;
+/**
+ * A link to a bug-report issue form, as {@link buildBugReportIssueFormLink} builds it.
+ */
+export interface BugReportIssueFormLink {
+    /**
+     * The text the user must paste into the form's environment field, when the full report did not fit the
+     * URL budget; `null` when the URL carries the whole report.
+     */
+    readonly clipboardText: null | string;
+    /**
+     * The link.
+     */
+    readonly url: string;
+}
+/**
+ * Parameters for {@link buildBugReportIssueFormLink}.
+ */
+export interface BuildBugReportIssueFormLinkParams {
+    /**
+     * The diagnostics the user agreed to include, appended to the environment field.
+     */
+    readonly diagnostics?: readonly BugReportDiagnosticSection[];
+    /**
+     * The environment, from {@link getBugReportEnvironment}.
+     */
+    readonly environment: BugReportEnvironment;
+    /**
+     * The plugin's GitHub repository, as `owner/name`.
+     */
+    readonly gitHubRepo: string;
+    /**
+     * The most characters the encoded URL may have before the report moves to the clipboard.
+     *
+     * @default {@link DEFAULT_BUG_REPORT_MAX_URL_LENGTH}
+     */
+    readonly maxUrlLength?: number;
+    /**
+     * The issue's title. Leave it out to keep the form's own default title.
+     */
+    readonly title?: string;
+}
+/**
+ * The text the environment field holds when the report moved to the clipboard.
+ */
+export declare const BUG_REPORT_PASTE_INSTRUCTIONS = "The full environment and diagnostics were copied to your clipboard because they are too long for a link. Replace this text by pasting them here.";
 /**
  * The environment a bug report needs.
  */
@@ -129,6 +183,17 @@ export interface GetGitHubIssueFormUrlParams {
      */
     readonly title?: string;
 }
+/**
+ * Builds a link to a plugin's bug-report issue form, prefilled with the environment and the given
+ * diagnostics. When the encoded link would be longer than
+ * {@link BuildBugReportIssueFormLinkParams.maxUrlLength}, the environment field gets
+ * {@link BUG_REPORT_PASTE_INSTRUCTIONS} instead, and the full text is returned as
+ * {@link BugReportIssueFormLink.clipboardText} for the caller to copy. Nothing is cut.
+ *
+ * @param params - The parameters.
+ * @returns The link, and the text to paste when it did not fit.
+ */
+export declare function buildBugReportIssueFormLink(params: BuildBugReportIssueFormLinkParams): BugReportIssueFormLink;
 /**
  * Renders a bug report's environment as a Markdown list.
  *

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

@@ -2,6 +2,33 @@
 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();
+})();
 (function patchObsidianRequire() {
   const originalRequire = require;
   if (!originalRequire || originalRequire.__isPatched) {
@@ -90,13 +117,26 @@ __export(open_bug_report_command_handler_exports, {
   OpenBugReportCommandHandler: () => OpenBugReportCommandHandler
 });
 module.exports = __toCommonJS(open_bug_report_command_handler_exports);
+var import_obsidian = require('obsidian');
 var import_bug_report = require('../bug-report.cjs');
+var import_i18n = require('../i18n/i18n.cjs');
+var import_copy_text_manually = require('../modals/copy-text-manually.cjs');
+var import_review_bug_report_diagnostics = require('../modals/review-bug-report-diagnostics.cjs');
 var import_open_git_hub_command_handler = require('./open-git-hub-command-handler.cjs');
+const CLIPBOARD_NOTICE_DURATION_IN_MILLISECONDS = 15e3;
 class OpenBugReportCommandHandler extends import_open_git_hub_command_handler.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.
    */
@@ -114,10 +154,46 @@ class OpenBugReportCommandHandler extends import_open_git_hub_command_handler.Op
       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 (0, import_bug_report.getBugReportEnvironment)({ app: this.app, pluginId: this.pluginId });
+    const sections = await this.getDiagnostics?.() ?? [];
+    let diagnostics = [];
+    if (sections.length > 0) {
+      const reviewedSections = await (0, import_review_bug_report_diagnostics.reviewBugReportDiagnostics)({
+        alwaysIncludedText: (0, import_bug_report.formatBugReportEnvironment)(environment),
+        app: this.app,
+        sections
+      });
+      if (reviewedSections === null) {
+        return;
+      }
+      diagnostics = reviewedSections;
+    }
+    const link = (0, import_bug_report.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.
    */
@@ -128,9 +204,24 @@ class OpenBugReportCommandHandler extends import_open_git_hub_command_handler.Op
       pluginId: this.pluginId
     });
   }
+  async copyReport(text) {
+    try {
+      await activeWindow.navigator.clipboard.writeText(text);
+      new import_obsidian.Notice((0, import_i18n.t)(($) => $.obsidianLib.bugReport.clipboardCopied), CLIPBOARD_NOTICE_DURATION_IN_MILLISECONDS);
+      return true;
+    } catch {
+      return await (0, import_copy_text_manually.copyTextManually)({
+        app: this.app,
+        message: (0, import_i18n.t)(($) => $.obsidianLib.bugReport.copyManuallyMessage),
+        okButtonText: (0, import_i18n.t)(($) => $.obsidianLib.bugReport.openIssueForm),
+        text,
+        title: (0, import_i18n.t)(($) => $.obsidianLib.bugReport.copyManuallyTitle)
+      });
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   OpenBugReportCommandHandler
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21tYW5kLWhhbmRsZXJzL29wZW4tYnVnLXJlcG9ydC1jb21tYW5kLWhhbmRsZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEhhbmRsZXMgdGhlIFwiUmVwb3J0IGEgYnVnXCIgY29tbWFuZC5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IEFwcCB9IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHsgZ2V0QnVnUmVwb3J0SXNzdWVGb3JtVXJsIH0gZnJvbSAnLi4vYnVnLXJlcG9ydC50cyc7XG5pbXBvcnQgeyBPcGVuR2l0SHViQ29tbWFuZEhhbmRsZXIgfSBmcm9tICcuL29wZW4tZ2l0LWh1Yi1jb21tYW5kLWhhbmRsZXIudHMnO1xuXG4vKipcbiAqIENvbnN0cnVjdG9yIHBhcmFtZXRlcnMgZm9yIHtAbGluayBPcGVuQnVnUmVwb3J0Q29tbWFuZEhhbmRsZXJ9LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIE9wZW5CdWdSZXBvcnRDb21tYW5kSGFuZGxlckNvbnN0cnVjdG9yUGFyYW1zIHtcbiAgLyoqXG4gICAqIFRoZSBPYnNpZGlhbiBhcHAgaW5zdGFuY2UuXG4gICAqL1xuICByZWFkb25seSBhcHA6IEFwcDtcblxuICAvKipcbiAgICogVGhlIHBsdWdpbidzIEdpdEh1YiByZXBvc2l0b3J5LCBhcyBgb3duZXIvbmFtZWAuXG4gICAqL1xuICByZWFkb25seSBnaXRIdWJSZXBvOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFRoZSBpZCBvZiB0aGUgcmVwb3J0aW5nIHBsdWdpbi5cbiAgICovXG4gIHJlYWRvbmx5IHBsdWdpbklkOiBzdHJpbmc7XG59XG5cbi8qKlxuICogQSBjb21tYW5kIGhhbmRsZXIgdGhhdCBvcGVucyB0aGUgcGx1Z2luJ3MgYnVnLXJlcG9ydCBpc3N1ZSBmb3JtIG9uIEdpdEh1YiwgcHJlZmlsbGVkIHdpdGggdGhlXG4gKiBlbnZpcm9ubWVudC4gU2VlIHtAbGluayBnZXRCdWdSZXBvcnRJc3N1ZUZvcm1Vcmx9IGZvciB0aGUgZmllbGQgaWRzIHRoZSBmb3JtIG11c3QgdXNlLlxuICovXG5leHBvcnQgY2xhc3MgT3BlbkJ1Z1JlcG9ydENvbW1hbmRIYW5kbGVyIGV4dGVuZHMgT3BlbkdpdEh1YkNvbW1hbmRIYW5kbGVyIHtcbiAgLyoqXG4gICAqIFRoZSBPYnNpZGlhbiBhcHAgaW5zdGFuY2UuXG4gICAqL1xuICBwcm90ZWN0ZWQgcmVhZG9ubHkgYXBwOiBBcHA7XG5cbiAgLyoqXG4gICAqIFRoZSBpZCBvZiB0aGUgcmVwb3J0aW5nIHBsdWdpbi5cbiAgICovXG4gIHByb3RlY3RlZCByZWFkb25seSBwbHVnaW5JZDogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBDb25zdHJ1Y3RzIGEgbmV3IGluc3RhbmNlLlxuICAgKlxuICAgKiBAcGFyYW0gcGFyYW1zIC0gQ29uc3RydWN0b3IgcGFyYW1ldGVycy5cbiAgICovXG4gIHB1YmxpYyBjb25zdHJ1Y3RvcihwYXJhbXM6IE9wZW5CdWdSZXBvcnRDb21tYW5kSGFuZGxlckNvbnN0cnVjdG9yUGFyYW1zKSB7XG4gICAgc3VwZXIoe1xuICAgICAgZ2l0SHViUmVwbzogcGFyYW1zLmdpdEh1YlJlcG8sXG4gICAgICBpY29uOiAnYnVnJyxcbiAgICAgIGlkOiAncmVwb3J0LWJ1ZycsXG4gICAgICBuYW1lOiAnUmVwb3J0IGEgYnVnJ1xuICAgIH0pO1xuXG4gICAgdGhpcy5hcHAgPSBwYXJhbXMuYXBwO1xuICAgIHRoaXMucGx1Z2luSWQgPSBwYXJhbXMucGx1Z2luSWQ7XG4gIH1cblxuICAvKipcbiAgICogQnVpbGRzIHRoZSBwcmVmaWxsZWQgYnVnLXJlcG9ydCBVUkwuXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBsaW5rLlxuICAgKi9cbiAgcHJvdGVjdGVkIG92ZXJyaWRlIGFzeW5jIGdldFVybCgpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIHJldHVybiBnZXRCdWdSZXBvcnRJc3N1ZUZvcm1Vcmwoe1xuICAgICAgYXBwOiB0aGlzLmFwcCxcbiAgICAgIGdpdEh1YlJlcG86IHRoaXMuZ2l0SHViUmVwbyxcbiAgICAgIHBsdWdpbklkOiB0aGlzLnBsdWdpbklkXG4gICAgfSk7XG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVFBLHdCQUF5QztBQUN6QywwQ0FBeUM7QUEwQmxDLE1BQU0sb0NBQW9DLDZEQUF5QjtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBSXJEO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFLQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU9aLFlBQVksUUFBc0Q7QUFDdkUsVUFBTTtBQUFBLE1BQ0osWUFBWSxPQUFPO0FBQUEsTUFDbkIsTUFBTTtBQUFBLE1BQ04sSUFBSTtBQUFBLE1BQ0osTUFBTTtBQUFBLElBQ1IsQ0FBQztBQUVELFNBQUssTUFBTSxPQUFPO0FBQ2xCLFNBQUssV0FBVyxPQUFPO0FBQUEsRUFDekI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPQSxNQUF5QixTQUEwQjtBQUNqRCxlQUFPLDRDQUF5QjtBQUFBLE1BQzlCLEtBQUssS0FBSztBQUFBLE1BQ1YsWUFBWSxLQUFLO0FBQUEsTUFDakIsVUFBVSxLQUFLO0FBQUEsSUFDakIsQ0FBQztBQUFBLEVBQ0g7QUFDRjsiLCJuYW1lcyI6W119
+//# 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,sBAAuB;AAIvB,wBAKO;AACP,kBAAkB;AAClB,gCAAiC;AACjC,2CAA2C;AAC3C,0CAAyC;AAsCzC,MAAM,4CAA4C;AAQ3C,MAAM,oCAAoC,6DAAyB;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,UAAM,2CAAwB,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,UAAM,iEAA2B;AAAA,QACxD,wBAAoB,8CAA2B,WAAW;AAAA,QAC1D,KAAK,KAAK;AAAA,QACV;AAAA,MACF,CAAC;AACD,UAAI,qBAAqB,MAAM;AAC7B;AAAA,MACF;AACA,oBAAc;AAAA,IAChB;AAEA,UAAM,WAAO,+CAA4B;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,eAAO,4CAAyB;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,2BAAO,eAAE,CAAC,MAAM,EAAE,YAAY,UAAU,eAAe,GAAG,yCAAyC;AACvG,aAAO;AAAA,IACT,QAAQ;AACN,aAAO,UAAM,4CAAiB;AAAA,QAC5B,KAAK,KAAK;AAAA,QACV,aAAS,eAAE,CAAC,MAAM,EAAE,YAAY,UAAU,mBAAmB;AAAA,QAC7D,kBAAc,eAAE,CAAC,MAAM,EAAE,YAAY,UAAU,aAAa;AAAA,QAC5D;AAAA,QACA,WAAO,eAAE,CAAC,MAAM,EAAE,YAAY,UAAU,iBAAiB;AAAA,MAC3D,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/lib/cjs/command-handlers/open-bug-report-command-handler.d.cts

@@ -5,6 +5,8 @@
  * Handles the "Report a bug" command.
  */
 import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
+import type { BugReportDiagnosticSection } from '../bug-report-diagnostics.cjs';
 import { OpenGitHubCommandHandler } from './open-git-hub-command-handler.cjs';
 /**
  * Constructor parameters for {@link OpenBugReportCommandHandler}.
@@ -14,10 +16,23 @@ export interface OpenBugReportCommandHandlerConstructorParams {
      * The Obsidian app instance.
      */
     readonly app: App;
+    /**
+     * Gets the optional diagnostics the report can carry, such as a `BugReportLogBuffer`'s section or the
+     * plugin's own redacted settings. Called each time the command runs. When it returns any section, the
+     * user reviews them and chooses which to include before the form opens; a potentially private section
+     * starts excluded. Leave it out to open the form with the environment only, as before.
+     */
+    readonly getDiagnostics?: () => Promisable<readonly BugReportDiagnosticSection[]>;
     /**
      * The plugin's GitHub repository, as `owner/name`.
      */
     readonly gitHubRepo: string;
+    /**
+     * The most characters the encoded link may have before the report moves to the clipboard.
+     *
+     * @default `DEFAULT_BUG_REPORT_MAX_URL_LENGTH`
+     */
+    readonly maxUrlLength?: number;
     /**
      * The id of the reporting plugin.
      */
@@ -25,13 +40,23 @@ export interface OpenBugReportCommandHandlerConstructorParams {
 }
 /**
  * A command handler that opens the plugin's bug-report issue form on GitHub, prefilled with the
- * environment. See {@link getBugReportIssueFormUrl} for the field ids the form must use.
+ * environment and any diagnostics the user agreed to include. See {@link getBugReportIssueFormUrl} for the
+ * field ids the form must use, and {@link buildBugReportIssueFormLink} for what happens to a report too long
+ * for a link.
  */
 export declare class OpenBugReportCommandHandler extends OpenGitHubCommandHandler {
     /**
      * The Obsidian app instance.
      */
     protected readonly app: App;
+    /**
+     * Gets the optional diagnostics the report can carry.
+     */
+    protected readonly getDiagnostics: (() => Promisable<readonly BugReportDiagnosticSection[]>) | undefined;
+    /**
+     * The most characters the encoded link may have before the report moves to the clipboard.
+     */
+    protected readonly maxUrlLength: number | undefined;
     /**
      * The id of the reporting plugin.
      */
@@ -43,9 +68,16 @@ export declare class OpenBugReportCommandHandler extends OpenGitHubCommandHandle
      */
     constructor(params: OpenBugReportCommandHandlerConstructorParams);
     /**
-     * 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.
+     */
+    execute(): Promise<void>;
+    /**
+     * Builds the prefilled bug-report URL, with the environment only.
      *
      * @returns The link.
      */
     protected getUrl(): Promise<string>;
+    private copyReport;
 }