@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

package/dist/lib/esm/desktop-request-url-stream.d.mts

@@ -0,0 +1,22 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * The desktop arm of {@link ./request-url.ts | requestUrlStream}: requests a URL through `node:http` /
+ * `node:https`, so the response body streams as it arrives and an abort really cancels the request.
+ *
+ * Desktop only: it reads `node:http` and `node:https`. Reach it through `requestUrlStream`, which imports it
+ * dynamically on desktop.
+ *
+ * Unlike Chromium's network stack, Node does not read the system proxy settings or certificate store, so a machine
+ * that reaches the internet only through a proxy, or that intercepts TLS with its own root certificate, needs the
+ * buffered `requestUrlEx` instead.
+ */
+import type { EncodedRequestUrlRequest, RequestUrlStreamResponse } from './request-url.mjs';
+/**
+ * Requests a URL through `node:http` / `node:https` and returns its body as a stream, following redirects.
+ *
+ * @param request - The encoded request.
+ * @returns The response, with a streamed body.
+ */
+export declare function openDesktopRequestUrlStream(request: EncodedRequestUrlRequest): Promise<RequestUrlStreamResponse>;

package/dist/lib/esm/desktop-request-url-stream.mjs

@@ -0,0 +1,170 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureDisposeSymbols();
+ensureBrowserProcess();
+})();
+
+import { onAbort } from "@mnaoumov/typescript-lib/abort-controller";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { request as requestHttp } from "node:http";
+import { request as requestHttps } from "node:https";
+const MAX_REDIRECT_COUNT = 20;
+const HTTP_MOVED_PERMANENTLY_STATUS = 301;
+const HTTP_FOUND_STATUS = 302;
+const HTTP_SEE_OTHER_STATUS = 303;
+const HTTP_TEMPORARY_REDIRECT_STATUS = 307;
+const HTTP_PERMANENT_REDIRECT_STATUS = 308;
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([
+  HTTP_FOUND_STATUS,
+  HTTP_MOVED_PERMANENTLY_STATUS,
+  HTTP_PERMANENT_REDIRECT_STATUS,
+  HTTP_SEE_OTHER_STATUS,
+  HTTP_TEMPORARY_REDIRECT_STATUS
+]);
+const BODY_HEADERS = /* @__PURE__ */ new Set(["content-length", "content-type"]);
+async function openDesktopRequestUrlStream(request) {
+  let currentRequest = {
+    abortSignal: request.abortSignal,
+    body: request.body,
+    headers: request.headers,
+    method: request.method,
+    url: request.url
+  };
+  for (let redirectCount = 0; ; redirectCount++) {
+    const incomingMessage = await sendRequest(currentRequest);
+    const status = ensureNonNullable(incomingMessage.statusCode);
+    const location = incomingMessage.headers.location;
+    if (!REDIRECT_STATUSES.has(status) || location === void 0) {
+      return {
+        body: createIncomingMessageStream(incomingMessage, request.abortSignal),
+        headers: flattenHeaders(incomingMessage.headers),
+        status,
+        url: currentRequest.url
+      };
+    }
+    incomingMessage.resume();
+    if (redirectCount >= MAX_REDIRECT_COUNT) {
+      throw new TypeError(`Too many redirects requesting ${request.url}`);
+    }
+    const nextUrl = new URL(location, currentRequest.url);
+    if (nextUrl.protocol !== "http:" && nextUrl.protocol !== "https:") {
+      throw new TypeError(`Unsupported protocol ${nextUrl.protocol} in the redirect to ${nextUrl.href}`);
+    }
+    currentRequest = getRedirectedRequest(currentRequest, status, nextUrl.href);
+  }
+}
+function createIncomingMessageStream(incomingMessage, abortSignal) {
+  let isSettled = false;
+  let abortListener;
+  return new ReadableStream({
+    cancel() {
+      isSettled = true;
+      abortListener[Symbol.dispose]();
+      incomingMessage.destroy();
+    },
+    pull() {
+      incomingMessage.resume();
+    },
+    start(controller) {
+      function settle(error) {
+        if (isSettled) {
+          return;
+        }
+        isSettled = true;
+        if (error === void 0) {
+          controller.close();
+        } else {
+          controller.error(error);
+        }
+      }
+      incomingMessage.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+        if (Number(controller.desiredSize) <= 0) {
+          incomingMessage.pause();
+        }
+      });
+      incomingMessage.on("end", () => {
+        abortListener[Symbol.dispose]();
+        settle();
+      });
+      incomingMessage.on("error", (error) => {
+        abortListener[Symbol.dispose]();
+        settle(error);
+      });
+      abortListener = onAbort(abortSignal, () => {
+        settle(abortSignal.reason);
+        incomingMessage.destroy(abortSignal.reason);
+      });
+    }
+  });
+}
+function flattenHeaders(headers) {
+  const flatHeaders = {};
+  for (const [name, value] of Object.entries(headers)) {
+    flatHeaders[name] = [value].flat().join(", ");
+  }
+  return flatHeaders;
+}
+function getRedirectedRequest(request, status, url) {
+  const shouldSwitchToGet = status === HTTP_SEE_OTHER_STATUS || request.method === "POST" && (status === HTTP_MOVED_PERMANENTLY_STATUS || status === HTTP_FOUND_STATUS);
+  if (!shouldSwitchToGet) {
+    return { ...request, url };
+  }
+  return {
+    abortSignal: request.abortSignal,
+    body: void 0,
+    headers: Object.fromEntries(Object.entries(request.headers).filter(([name]) => !BODY_HEADERS.has(name.toLowerCase()))),
+    method: "GET",
+    url
+  };
+}
+async function sendRequest(params) {
+  const request = params.url.startsWith("https:") ? requestHttps : requestHttp;
+  return await new Promise((resolve, reject) => {
+    const clientRequest = request(params.url, {
+      headers: { ...params.headers },
+      method: params.method,
+      signal: params.abortSignal
+    }, resolve);
+    clientRequest.on("error", (error) => {
+      reject(params.abortSignal.aborted ? params.abortSignal.reason : error);
+    });
+    clientRequest.end(typeof params.body === "string" ? params.body : params.body && new Uint8Array(params.body));
+  });
+}
+export {
+  openDesktopRequestUrlStream
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/desktop-request-url-stream.ts"],"sourcesContent":["/**\n * @file\n *\n * The desktop arm of {@link ./request-url.ts | requestUrlStream}: requests a URL through `node:http` /\n * `node:https`, so the response body streams as it arrives and an abort really cancels the request.\n *\n * Desktop only: it reads `node:http` and `node:https`. Reach it through `requestUrlStream`, which imports it\n * dynamically on desktop.\n *\n * Unlike Chromium's network stack, Node does not read the system proxy settings or certificate store, so a machine\n * that reaches the internet only through a proxy, or that intercepts TLS with its own root certificate, needs the\n * buffered `requestUrlEx` instead.\n */\n\n/* eslint-disable n/no-unsupported-features/node-builtins -- ReadableStream is the Obsidian renderer's Web API, not a Node builtin. */\n\nimport type {\n  IncomingHttpHeaders,\n  IncomingMessage\n} from 'node:http';\n\nimport { onAbort } from '@mnaoumov/typescript-lib/abort-controller';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { request as requestHttp } from 'node:http';\nimport { request as requestHttps } from 'node:https';\n\nimport type {\n  EncodedRequestUrlRequest,\n  RequestUrlStreamResponse\n} from './request-url.ts';\n\nconst MAX_REDIRECT_COUNT = 20;\nconst HTTP_MOVED_PERMANENTLY_STATUS = 301;\nconst HTTP_FOUND_STATUS = 302;\nconst HTTP_SEE_OTHER_STATUS = 303;\nconst HTTP_TEMPORARY_REDIRECT_STATUS = 307;\nconst HTTP_PERMANENT_REDIRECT_STATUS = 308;\nconst REDIRECT_STATUSES = new Set([\n  HTTP_FOUND_STATUS,\n  HTTP_MOVED_PERMANENTLY_STATUS,\n  HTTP_PERMANENT_REDIRECT_STATUS,\n  HTTP_SEE_OTHER_STATUS,\n  HTTP_TEMPORARY_REDIRECT_STATUS\n]);\nconst BODY_HEADERS = new Set(['content-length', 'content-type']);\n\ninterface SendRequestParams {\n  readonly abortSignal: AbortSignal;\n  readonly body: ArrayBuffer | string | undefined;\n  readonly headers: Readonly<Record<string, string>>;\n  readonly method: string;\n  readonly url: string;\n}\n\n/**\n * Requests a URL through `node:http` / `node:https` and returns its body as a stream, following redirects.\n *\n * @param request - The encoded request.\n * @returns The response, with a streamed body.\n */\nexport async function openDesktopRequestUrlStream(request: EncodedRequestUrlRequest): Promise<RequestUrlStreamResponse> {\n  let currentRequest: SendRequestParams = {\n    abortSignal: request.abortSignal,\n    body: request.body,\n    headers: request.headers,\n    method: request.method,\n    url: request.url\n  };\n\n  for (let redirectCount = 0;; redirectCount++) {\n    const incomingMessage = await sendRequest(currentRequest);\n    // A response to a client request always carries its status code.\n    const status = ensureNonNullable(incomingMessage.statusCode);\n    const location = incomingMessage.headers.location;\n    if (!REDIRECT_STATUSES.has(status) || location === undefined) {\n      return {\n        body: createIncomingMessageStream(incomingMessage, request.abortSignal),\n        headers: flattenHeaders(incomingMessage.headers),\n        status,\n        url: currentRequest.url\n      };\n    }\n\n    incomingMessage.resume();\n    if (redirectCount >= MAX_REDIRECT_COUNT) {\n      throw new TypeError(`Too many redirects requesting ${request.url}`);\n    }\n    const nextUrl = new URL(location, currentRequest.url);\n    if (nextUrl.protocol !== 'http:' && nextUrl.protocol !== 'https:') {\n      throw new TypeError(`Unsupported protocol ${nextUrl.protocol} in the redirect to ${nextUrl.href}`);\n    }\n    currentRequest = getRedirectedRequest(currentRequest, status, nextUrl.href);\n  }\n}\n\nfunction createIncomingMessageStream(incomingMessage: IncomingMessage, abortSignal: AbortSignal): ReadableStream<Uint8Array> {\n  let isSettled = false;\n  // Assigned in `start`, which runs inside the constructor, so it is in place before `cancel` can run.\n  let abortListener: Disposable;\n  return new ReadableStream<Uint8Array>({\n    cancel(): void {\n      isSettled = true;\n      abortListener[Symbol.dispose]();\n      incomingMessage.destroy();\n    },\n    pull(): void {\n      incomingMessage.resume();\n    },\n    start(controller): void {\n      function settle(error?: unknown): void {\n        if (isSettled) {\n          return;\n        }\n        isSettled = true;\n        if (error === undefined) {\n          controller.close();\n        } else {\n          controller.error(error);\n        }\n      }\n\n      incomingMessage.on('data', (chunk: Buffer) => {\n        // A copy, so the chunk belongs to the renderer's realm whatever Node does with its buffer afterwards.\n        controller.enqueue(new Uint8Array(chunk));\n        if (Number(controller.desiredSize) <= 0) {\n          incomingMessage.pause();\n        }\n      });\n      incomingMessage.on('end', () => {\n        abortListener[Symbol.dispose]();\n        settle();\n      });\n      incomingMessage.on('error', (error) => {\n        abortListener[Symbol.dispose]();\n        settle(error);\n      });\n      abortListener = onAbort(abortSignal, () => {\n        settle(abortSignal.reason);\n        // The `error` event this raises finds the stream settled already.\n        incomingMessage.destroy(abortSignal.reason as Error);\n      });\n    }\n  });\n}\nfunction flattenHeaders(headers: IncomingHttpHeaders): Record<string, string> {\n  const flatHeaders: Record<string, string> = {};\n  for (const [name, value] of Object.entries(headers)) {\n    // Node joins every repeated header but `set-cookie`, which arrives as an array.\n    flatHeaders[name] = [value].flat().join(', ');\n  }\n  return flatHeaders;\n}\n\nfunction getRedirectedRequest(request: SendRequestParams, status: number, url: string): SendRequestParams {\n  // What `fetch` does: a 303, and a 301 or 302 answering a POST, become a GET without a body.\n  const shouldSwitchToGet = status === HTTP_SEE_OTHER_STATUS\n    || (request.method === 'POST' && (status === HTTP_MOVED_PERMANENTLY_STATUS || status === HTTP_FOUND_STATUS));\n  if (!shouldSwitchToGet) {\n    return { ...request, url };\n  }\n  return {\n    abortSignal: request.abortSignal,\n    body: undefined,\n    headers: Object.fromEntries(Object.entries(request.headers).filter(([name]) => !BODY_HEADERS.has(name.toLowerCase()))),\n    method: 'GET',\n    url\n  };\n}\n\nasync function sendRequest(params: SendRequestParams): Promise<IncomingMessage> {\n  const request = params.url.startsWith('https:') ? requestHttps : requestHttp;\n  return await new Promise((resolve, reject) => {\n    const clientRequest = request(params.url, {\n      headers: { ...params.headers },\n      method: params.method,\n      signal: params.abortSignal\n    }, resolve);\n    clientRequest.on('error', (error) => {\n      reject(params.abortSignal.aborted ? params.abortSignal.reason as Error : error);\n    });\n    clientRequest.end(typeof params.body === 'string' ? params.body : params.body && new Uint8Array(params.body));\n  });\n}\n/* eslint-enable n/no-unsupported-features/node-builtins -- ReadableStream is the Obsidian renderer's Web API, not a Node builtin. */\n"],"mappings":"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","names":[]}

package/dist/lib/esm/editor-suggest-registrar.d.mts

@@ -13,8 +13,19 @@ export interface EditorSuggestRegistrar {
      * Registers an editor suggest.
      *
      * @param editorSuggest - The editor suggest to register.
+     * @param options - The options.
      */
-    readonly registerEditorSuggest: (editorSuggest: EditorSuggest<unknown>) => void;
+    readonly registerEditorSuggest: (editorSuggest: EditorSuggest<unknown>, options?: RegisterEditorSuggestOptions) => void;
+}
+/**
+ * Options for {@link EditorSuggestRegistrar.registerEditorSuggest}.
+ */
+export interface RegisterEditorSuggestOptions {
+    /**
+     * Whether the suggest is asked before the others already registered, Obsidian's own included. Defaults to `false`:
+     * registration order decides.
+     */
+    readonly shouldPrioritize?: boolean;
 }
 /**
  * Editor suggest registrar in an Obsidian plugin.
@@ -31,6 +42,7 @@ export declare class PluginEditorSuggestRegistrar implements EditorSuggestRegist
      * Registers an editor suggest.
      *
      * @param editorSuggest - The editor suggest to register.
+     * @param options - The options.
      */
-    registerEditorSuggest(editorSuggest: EditorSuggest<unknown>): void;
+    registerEditorSuggest(editorSuggest: EditorSuggest<unknown>, options?: RegisterEditorSuggestOptions): void;
 }

package/dist/lib/esm/editor-suggest-registrar.mjs

@@ -34,6 +34,7 @@ import {
   EditorSuggest,
   Plugin
 } from "obsidian";
+import { prioritizeEditorSuggest } from "./editor-suggest.mjs";
 class PluginEditorSuggestRegistrar {
   /**
    * Creates a new instance of the {@link PluginEditorSuggestRegistrar} class.
@@ -48,12 +49,17 @@ class PluginEditorSuggestRegistrar {
    * Registers an editor suggest.
    *
    * @param editorSuggest - The editor suggest to register.
+   * @param options - The options.
    */
-  registerEditorSuggest(editorSuggest) {
+  // eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- It implements `EditorSuggestRegistrar.registerEditorSuggest`, whose options type every registrar shares.
+  registerEditorSuggest(editorSuggest, options) {
     this.plugin.registerEditorSuggest(editorSuggest);
+    if (options?.shouldPrioritize) {
+      prioritizeEditorSuggest({ app: this.plugin.app, editorSuggest });
+    }
   }
 }
 export {
   PluginEditorSuggestRegistrar
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lZGl0b3Itc3VnZ2VzdC1yZWdpc3RyYXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEVkaXRvciBzdWdnZXN0IHJlZ2lzdHJhcnMuXG4gKi9cblxuaW1wb3J0IHtcbiAgRWRpdG9yU3VnZ2VzdCxcbiAgUGx1Z2luXG59IGZyb20gJ29ic2lkaWFuJztcblxuLyoqXG4gKiBFZGl0b3Igc3VnZ2VzdCByZWdpc3RyYXIuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRWRpdG9yU3VnZ2VzdFJlZ2lzdHJhciB7XG4gIC8qKlxuICAgKiBSZWdpc3RlcnMgYW4gZWRpdG9yIHN1Z2dlc3QuXG4gICAqXG4gICAqIEBwYXJhbSBlZGl0b3JTdWdnZXN0IC0gVGhlIGVkaXRvciBzdWdnZXN0IHRvIHJlZ2lzdGVyLlxuICAgKi9cbiAgcmVhZG9ubHkgcmVnaXN0ZXJFZGl0b3JTdWdnZXN0OiAoZWRpdG9yU3VnZ2VzdDogRWRpdG9yU3VnZ2VzdDx1bmtub3duPikgPT4gdm9pZDtcbn1cblxuLyoqXG4gKiBFZGl0b3Igc3VnZ2VzdCByZWdpc3RyYXIgaW4gYW4gT2JzaWRpYW4gcGx1Z2luLlxuICovXG5leHBvcnQgY2xhc3MgUGx1Z2luRWRpdG9yU3VnZ2VzdFJlZ2lzdHJhciBpbXBsZW1lbnRzIEVkaXRvclN1Z2dlc3RSZWdpc3RyYXIge1xuICAvKipcbiAgICogQ3JlYXRlcyBhIG5ldyBpbnN0YW5jZSBvZiB0aGUge0BsaW5rIFBsdWdpbkVkaXRvclN1Z2dlc3RSZWdpc3RyYXJ9IGNsYXNzLlxuICAgKlxuICAgKiBAcGFyYW0gcGx1Z2luIC0gVGhlIE9ic2lkaWFuIHBsdWdpbiBpbnN0YW5jZS5cbiAgICovXG4gIHB1YmxpYyBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgcmVhZG9ubHkgcGx1Z2luOiBQbHVnaW4pIHt9XG5cbiAgLyoqXG4gICAqIFJlZ2lzdGVycyBhbiBlZGl0b3Igc3VnZ2VzdC5cbiAgICpcbiAgICogQHBhcmFtIGVkaXRvclN1Z2dlc3QgLSBUaGUgZWRpdG9yIHN1Z2dlc3QgdG8gcmVnaXN0ZXIuXG4gICAqL1xuICBwdWJsaWMgcmVnaXN0ZXJFZGl0b3JTdWdnZXN0KGVkaXRvclN1Z2dlc3Q6IEVkaXRvclN1Z2dlc3Q8dW5rbm93bj4pOiB2b2lkIHtcbiAgICB0aGlzLnBsdWdpbi5yZWdpc3RlckVkaXRvclN1Z2dlc3QoZWRpdG9yU3VnZ2VzdCk7XG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFNQTtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsT0FDSztBQWlCQSxNQUFNLDZCQUErRDtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU1uRSxZQUErQixRQUFnQjtBQUFoQjtBQUFBLEVBQWlCO0FBQUEsRUFBakI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPL0Isc0JBQXNCLGVBQTZDO0FBQ3hFLFNBQUssT0FBTyxzQkFBc0IsYUFBYTtBQUFBLEVBQ2pEO0FBQ0Y7IiwibmFtZXMiOltdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/editor-suggest.d.mts

@@ -0,0 +1,103 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Helpers for `EditorSuggest`: giving one priority over the others, and opening one from a command.
+ *
+ * Read from Obsidian `1.15.0`: the editor asks each suggest in `app.workspace.editorSuggest.suggests` in order, and the
+ * first whose `trigger` accepts the cursor wins, so registration order decides which suggest opens. A suggest shows its
+ * list only when the trigger is explicit (the user typed) or it is already open.
+ */
+import type { App, Editor, EditorPosition, EditorSuggestTriggerInfo, TFile } from 'obsidian';
+import { EditorSuggest } from 'obsidian';
+/**
+ * Parameters for {@link CommandEditorSuggest.openFromCommand}.
+ */
+export interface CommandEditorSuggestOpenFromCommandParams {
+    /**
+     * The editor to open the suggest in.
+     */
+    readonly editor: Editor;
+    /**
+     * The file open in the editor.
+     */
+    readonly file: null | TFile;
+}
+/**
+ * Parameters for {@link prioritizeEditorSuggest}.
+ */
+export interface PrioritizeEditorSuggestParams {
+    /**
+     * The Obsidian app.
+     */
+    readonly app: App;
+    /**
+     * The registered editor suggest.
+     */
+    readonly editorSuggest: EditorSuggest<unknown>;
+}
+/**
+ * An editor suggest that a command can open at the cursor, without a trigger character.
+ *
+ * {@link CommandEditorSuggest.openFromCommand} opens it at the cursor; the text typed after that point, on the same
+ * line, is the query, and moving the cursor before that point or off the line closes it. A subclass may still open on
+ * typed text by overriding {@link CommandEditorSuggest.onTextTrigger}.
+ *
+ * Register it as usual, so the editor keeps it updated while the user types:
+ *
+ * ```ts
+ * const suggest = new EmojiSuggest(this.app);
+ * this.registerEditorSuggest(suggest);
+ * this.addCommand({
+ *   editorCallback: (editor, ctx) => {
+ *     suggest.openFromCommand({ editor, file: ctx.file });
+ *   },
+ *   id: 'insert-emoji',
+ *   name: 'Insert emoji'
+ * });
+ * ```
+ *
+ * @typeParam T - The type of a suggestion.
+ */
+export declare abstract class CommandEditorSuggest<T> extends EditorSuggest<T> {
+    private commandStart;
+    /**
+     * Closes the suggest, ending a command-opened session.
+     */
+    close(): void;
+    /**
+     * Decides whether the suggest opens. While a command-opened session lasts, the query is the text from where it was
+     * opened to the cursor; otherwise {@link CommandEditorSuggest.onTextTrigger} decides.
+     *
+     * @param cursor - The cursor.
+     * @param editor - The editor.
+     * @param file - The file open in the editor.
+     * @returns The trigger info, or `null` to stay closed.
+     */
+    onTrigger(cursor: EditorPosition, editor: Editor, file: null | TFile): EditorSuggestTriggerInfo | null;
+    /**
+     * Opens the suggest at the cursor of an editor, typically from a command's `editorCallback`.
+     *
+     * @param params - The parameters.
+     * @returns Whether the suggest accepted the cursor: `false` when text is selected.
+     */
+    openFromCommand(params: CommandEditorSuggestOpenFromCommandParams): boolean;
+    /**
+     * Decides whether the suggest opens on typed text, outside a command-opened session. Never, by default.
+     *
+     * @param _cursor - The cursor.
+     * @param _editor - The editor.
+     * @param _file - The file open in the editor.
+     * @returns The trigger info, or `null` to stay closed.
+     */
+    protected onTextTrigger(_cursor: EditorPosition, _editor: Editor, _file: null | TFile): EditorSuggestTriggerInfo | null;
+}
+/**
+ * Moves a registered editor suggest to the front of the list the editor asks, so it opens ahead of every other suggest
+ * whose trigger accepts the same text, Obsidian's own `[[` and `#` suggests included. A suggest prioritized later goes
+ * ahead of it in turn.
+ *
+ * @param params - The parameters.
+ * @throws If the editor suggest is not registered.
+ */
+export declare function prioritizeEditorSuggest(params: PrioritizeEditorSuggestParams): void;

package/dist/lib/esm/editor-suggest.mjs

@@ -0,0 +1,108 @@
+/*
+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 { EditorSuggest } from "obsidian";
+class CommandEditorSuggest extends EditorSuggest {
+  commandStart = null;
+  /**
+   * Closes the suggest, ending a command-opened session.
+   */
+  close() {
+    this.commandStart = null;
+    super.close();
+  }
+  /**
+   * Decides whether the suggest opens. While a command-opened session lasts, the query is the text from where it was
+   * opened to the cursor; otherwise {@link CommandEditorSuggest.onTextTrigger} decides.
+   *
+   * @param cursor - The cursor.
+   * @param editor - The editor.
+   * @param file - The file open in the editor.
+   * @returns The trigger info, or `null` to stay closed.
+   */
+  onTrigger(cursor, editor, file) {
+    const start = this.commandStart;
+    if (start) {
+      if (cursor.line === start.line && cursor.ch >= start.ch) {
+        return {
+          end: cursor,
+          query: editor.getLine(cursor.line).slice(start.ch, cursor.ch),
+          start
+        };
+      }
+      this.commandStart = null;
+    }
+    return this.onTextTrigger(cursor, editor, file);
+  }
+  /**
+   * Opens the suggest at the cursor of an editor, typically from a command's `editorCallback`.
+   *
+   * @param params - The parameters.
+   * @returns Whether the suggest accepted the cursor: `false` when text is selected.
+   */
+  openFromCommand(params) {
+    const { editor, file } = params;
+    this.commandStart = editor.getCursor();
+    if (!this.trigger(editor, file, true)) {
+      this.commandStart = null;
+      return false;
+    }
+    this.app.workspace.editorSuggest.setCurrentSuggest(this);
+    return true;
+  }
+  /**
+   * Decides whether the suggest opens on typed text, outside a command-opened session. Never, by default.
+   *
+   * @param _cursor - The cursor.
+   * @param _editor - The editor.
+   * @param _file - The file open in the editor.
+   * @returns The trigger info, or `null` to stay closed.
+   */
+  onTextTrigger(_cursor, _editor, _file) {
+    return null;
+  }
+}
+function prioritizeEditorSuggest(params) {
+  const { app, editorSuggest } = params;
+  const suggests = app.workspace.editorSuggest.suggests;
+  const index = suggests.indexOf(editorSuggest);
+  if (index === -1) {
+    throw new Error("The editor suggest is not registered. Register it before prioritizing it.");
+  }
+  suggests.splice(index, 1);
+  suggests.unshift(editorSuggest);
+}
+export {
+  CommandEditorSuggest,
+  prioritizeEditorSuggest
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/editor-suggest.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for `EditorSuggest`: giving one priority over the others, and opening one from a command.\n *\n * Read from Obsidian `1.15.0`: the editor asks each suggest in `app.workspace.editorSuggest.suggests` in order, and the\n * first whose `trigger` accepts the cursor wins, so registration order decides which suggest opens. A suggest shows its\n * list only when the trigger is explicit (the user typed) or it is already open.\n */\n\nimport type {\n  App,\n  Editor,\n  EditorPosition,\n  EditorSuggestTriggerInfo,\n  TFile\n} from 'obsidian';\n\nimport { EditorSuggest } from 'obsidian';\n\n/**\n * Parameters for {@link CommandEditorSuggest.openFromCommand}.\n */\nexport interface CommandEditorSuggestOpenFromCommandParams {\n  /**\n   * The editor to open the suggest in.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The file open in the editor.\n   */\n  readonly file: null | TFile;\n}\n\n/**\n * Parameters for {@link prioritizeEditorSuggest}.\n */\nexport interface PrioritizeEditorSuggestParams {\n  /**\n   * The Obsidian app.\n   */\n  readonly app: App;\n\n  /**\n   * The registered editor suggest.\n   */\n  readonly editorSuggest: EditorSuggest<unknown>;\n}\n\n/**\n * An editor suggest that a command can open at the cursor, without a trigger character.\n *\n * {@link CommandEditorSuggest.openFromCommand} opens it at the cursor; the text typed after that point, on the same\n * line, is the query, and moving the cursor before that point or off the line closes it. A subclass may still open on\n * typed text by overriding {@link CommandEditorSuggest.onTextTrigger}.\n *\n * Register it as usual, so the editor keeps it updated while the user types:\n *\n * ```ts\n * const suggest = new EmojiSuggest(this.app);\n * this.registerEditorSuggest(suggest);\n * this.addCommand({\n *   editorCallback: (editor, ctx) => {\n *     suggest.openFromCommand({ editor, file: ctx.file });\n *   },\n *   id: 'insert-emoji',\n *   name: 'Insert emoji'\n * });\n * ```\n *\n * @typeParam T - The type of a suggestion.\n */\nexport abstract class CommandEditorSuggest<T> extends EditorSuggest<T> {\n  private commandStart: EditorPosition | null = null;\n\n  /**\n   * Closes the suggest, ending a command-opened session.\n   */\n  public override close(): void {\n    this.commandStart = null;\n    super.close();\n  }\n\n  /**\n   * Decides whether the suggest opens. While a command-opened session lasts, the query is the text from where it was\n   * opened to the cursor; otherwise {@link CommandEditorSuggest.onTextTrigger} decides.\n   *\n   * @param cursor - The cursor.\n   * @param editor - The editor.\n   * @param file - The file open in the editor.\n   * @returns The trigger info, or `null` to stay closed.\n   */\n  public override onTrigger(cursor: EditorPosition, editor: Editor, file: null | TFile): EditorSuggestTriggerInfo | null {\n    const start = this.commandStart;\n    if (start) {\n      if (cursor.line === start.line && cursor.ch >= start.ch) {\n        return {\n          end: cursor,\n          query: editor.getLine(cursor.line).slice(start.ch, cursor.ch),\n          start\n        };\n      }\n      this.commandStart = null;\n    }\n    return this.onTextTrigger(cursor, editor, file);\n  }\n\n  /**\n   * Opens the suggest at the cursor of an editor, typically from a command's `editorCallback`.\n   *\n   * @param params - The parameters.\n   * @returns Whether the suggest accepted the cursor: `false` when text is selected.\n   */\n  public openFromCommand(params: CommandEditorSuggestOpenFromCommandParams): boolean {\n    const { editor, file } = params;\n    this.commandStart = editor.getCursor();\n    if (!this.trigger(editor, file, true)) {\n      this.commandStart = null;\n      return false;\n    }\n    this.app.workspace.editorSuggest.setCurrentSuggest(this);\n    return true;\n  }\n\n  /**\n   * Decides whether the suggest opens on typed text, outside a command-opened session. Never, by default.\n   *\n   * @param _cursor - The cursor.\n   * @param _editor - The editor.\n   * @param _file - The file open in the editor.\n   * @returns The trigger info, or `null` to stay closed.\n   */\n  protected onTextTrigger(_cursor: EditorPosition, _editor: Editor, _file: null | TFile): EditorSuggestTriggerInfo | null {\n    return null;\n  }\n}\n\n/**\n * Moves a registered editor suggest to the front of the list the editor asks, so it opens ahead of every other suggest\n * whose trigger accepts the same text, Obsidian's own `[[` and `#` suggests included. A suggest prioritized later goes\n * ahead of it in turn.\n *\n * @param params - The parameters.\n * @throws If the editor suggest is not registered.\n */\nexport function prioritizeEditorSuggest(params: PrioritizeEditorSuggestParams): void {\n  const { app, editorSuggest } = params;\n  const suggests = app.workspace.editorSuggest.suggests;\n  const index = suggests.indexOf(editorSuggest);\n  if (index === -1) {\n    throw new Error('The editor suggest is not registered. Register it before prioritizing it.');\n  }\n  suggests.splice(index, 1);\n  suggests.unshift(editorSuggest);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAS,qBAAqB;AAuDvB,MAAe,6BAAgC,cAAiB;AAAA,EAC7D,eAAsC;AAAA;AAAA;AAAA;AAAA,EAK9B,QAAc;AAC5B,SAAK,eAAe;AACpB,UAAM,MAAM;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWgB,UAAU,QAAwB,QAAgB,MAAqD;AACrH,UAAM,QAAQ,KAAK;AACnB,QAAI,OAAO;AACT,UAAI,OAAO,SAAS,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI;AACvD,eAAO;AAAA,UACL,KAAK;AAAA,UACL,OAAO,OAAO,QAAQ,OAAO,IAAI,EAAE,MAAM,MAAM,IAAI,OAAO,EAAE;AAAA,UAC5D;AAAA,QACF;AAAA,MACF;AACA,WAAK,eAAe;AAAA,IACtB;AACA,WAAO,KAAK,cAAc,QAAQ,QAAQ,IAAI;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,gBAAgB,QAA4D;AACjF,UAAM,EAAE,QAAQ,KAAK,IAAI;AACzB,SAAK,eAAe,OAAO,UAAU;AACrC,QAAI,CAAC,KAAK,QAAQ,QAAQ,MAAM,IAAI,GAAG;AACrC,WAAK,eAAe;AACpB,aAAO;AAAA,IACT;AACA,SAAK,IAAI,UAAU,cAAc,kBAAkB,IAAI;AACvD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUU,cAAc,SAAyB,SAAiB,OAAsD;AACtH,WAAO;AAAA,EACT;AACF;AAUO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,EAAE,KAAK,cAAc,IAAI;AAC/B,QAAM,WAAW,IAAI,UAAU,cAAc;AAC7C,QAAM,QAAQ,SAAS,QAAQ,aAAa;AAC5C,MAAI,UAAU,IAAI;AAChB,UAAM,IAAI,MAAM,2EAA2E;AAAA,EAC7F;AACA,WAAS,OAAO,OAAO,CAAC;AACxB,WAAS,QAAQ,aAAa;AAChC;","names":[]}

package/dist/lib/esm/feature-request.d.mts

@@ -0,0 +1,54 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Links to a plugin's feature-request issue form without collecting a bug-report environment.
+ */
+import type { App } from 'obsidian';
+/**
+ * The feature-request form's file name under `.github/ISSUE_TEMPLATE`.
+ */
+export declare const FEATURE_REQUEST_ISSUE_FORM_TEMPLATE = "feature_request.yml";
+/**
+ * Field ids the feature-request form must use for prefilling.
+ */
+export declare enum FeatureRequestIssueFormFieldId {
+    /**
+     * The requesting plugin's installed version.
+     */
+    PluginVersion = "plugin-version"
+}
+/**
+ * Parameters for {@link getFeatureRequestIssueFormUrl}.
+ */
+export interface GetFeatureRequestIssueFormUrlParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The repository, as `owner/name`.
+     */
+    readonly gitHubRepo: string;
+    /**
+     * The requesting plugin's id.
+     */
+    readonly pluginId: string;
+    /**
+     * The form's file name under `.github/ISSUE_TEMPLATE`.
+     *
+     * @default {@link FEATURE_REQUEST_ISSUE_FORM_TEMPLATE}
+     */
+    readonly template?: string;
+    /**
+     * The issue's title. Omit to keep the form's default title.
+     */
+    readonly title?: string;
+}
+/**
+ * Gets the feature-request form URL, prefilling only {@link FeatureRequestIssueFormFieldId.PluginVersion}.
+ *
+ * @param params - The parameters.
+ * @returns The link.
+ */
+export declare function getFeatureRequestIssueFormUrl(params: GetFeatureRequestIssueFormUrlParams): string;

package/dist/lib/esm/feature-request.mjs

@@ -0,0 +1,25 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { getGitHubIssueFormUrl } from "./bug-report.mjs";
+const FEATURE_REQUEST_ISSUE_FORM_TEMPLATE = "feature_request.yml";
+var FeatureRequestIssueFormFieldId = /* @__PURE__ */ ((FeatureRequestIssueFormFieldId2) => {
+  FeatureRequestIssueFormFieldId2["PluginVersion"] = "plugin-version";
+  return FeatureRequestIssueFormFieldId2;
+})(FeatureRequestIssueFormFieldId || {});
+function getFeatureRequestIssueFormUrl(params) {
+  return getGitHubIssueFormUrl({
+    fields: { ["plugin-version" /* PluginVersion */]: params.app.plugins.manifests[params.pluginId]?.version ?? "unknown" },
+    gitHubRepo: params.gitHubRepo,
+    template: params.template ?? FEATURE_REQUEST_ISSUE_FORM_TEMPLATE,
+    ...params.title !== void 0 && { title: params.title }
+  });
+}
+export {
+  FEATURE_REQUEST_ISSUE_FORM_TEMPLATE,
+  FeatureRequestIssueFormFieldId,
+  getFeatureRequestIssueFormUrl
+};
+//# sourceMappingURL=data:application/json;base64,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