@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

package/dist/lib/cjs/inline-token-renderer.d.cts

@@ -0,0 +1,88 @@
+/// <reference path="./library-references.d.cts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * One definition of an inline token that renders in both Reading view and Live Preview.
+ *
+ * A token is a regular expression and a render function. {@link registerInlineTokenRenderer} registers a Markdown
+ * post processor that renders every match found in the rendered text, and an editor extension that replaces every
+ * match with a widget in Live Preview, both calling the same function, so the two views cannot drift apart.
+ *
+ * The Reading-view half walks text nodes only, so a token is never matched across an element boundary, and it skips
+ * text inside the elements `skipSelector` names (code by default). The editor half matches each line's source text,
+ * Markdown markup included; see `shouldDecorate` to skip code there.
+ */
+import type { MarkdownPostProcessorContext } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { CreateInlineTokenWidgetsExtensionParams, InlineTokenRenderFunction } from './codemirror/inline-token-widgets.cjs';
+import type { EditorExtensionRegistrar } from './editor-extension-registrar.cjs';
+import type { MarkdownPostProcessorRegistrar } from './markdown-post-processor-registrar.cjs';
+/**
+ * The default selector of the elements whose text is never matched in Reading view.
+ */
+export declare const DEFAULT_INLINE_TOKEN_SKIP_SELECTOR = "code, pre";
+/**
+ * Parameters for {@link createInlineTokenPostProcessor}.
+ */
+export interface CreateInlineTokenPostProcessorParams {
+    /**
+     * The regular expression a token matches. The `g` flag is added when missing.
+     */
+    readonly regExp: RegExp;
+    /**
+     * Renders a token into its element.
+     */
+    readonly render: InlineTokenRenderFunction;
+    /**
+     * The selector of the elements whose text is never matched.
+     *
+     * @default {@link DEFAULT_INLINE_TOKEN_SKIP_SELECTOR}
+     */
+    readonly skipSelector?: string;
+}
+/**
+ * Parameters for {@link registerInlineTokenRenderer}.
+ */
+export interface RegisterInlineTokenRendererParams extends CreateInlineTokenPostProcessorParams, CreateInlineTokenWidgetsExtensionParams {
+    /**
+     * The registrar the editor extension is registered through.
+     */
+    readonly editorExtensionRegistrar: EditorExtensionRegistrar;
+    /**
+     * The registrar the Reading-view post processor is registered through.
+     */
+    readonly markdownPostProcessorRegistrar: MarkdownPostProcessorRegistrar;
+    /**
+     * The sort order of the post processor.
+     *
+     * @default `0`
+     */
+    readonly sortOrder?: number;
+}
+/**
+ * Creates a Markdown post processor that renders every match of a regular expression found in the rendered text.
+ *
+ * @param params - The post processor parameters.
+ * @returns The post processor.
+ */
+export declare function createInlineTokenPostProcessor(params: CreateInlineTokenPostProcessorParams): (element: HTMLElement, context: Pick<MarkdownPostProcessorContext, 'sourcePath'>) => void;
+/**
+ * Registers an inline token in both Reading view and Live Preview, from one definition.
+ *
+ * Obsidian ties both registrations to the plugin's lifetime and offers no way to remove either earlier.
+ *
+ * @param params - The registration parameters.
+ *
+ * @example
+ * ```ts
+ * registerInlineTokenRenderer({
+ *   editorExtensionRegistrar: new PluginEditorExtensionRegistrar(this),
+ *   markdownPostProcessorRegistrar: new PluginMarkdownPostProcessorRegistrar(this),
+ *   regExp: /:([a-z]+):/,
+ *   render({ containerEl, match }) {
+ *     containerEl.setText(EMOJI[match[1] ?? ''] ?? match[0]);
+ *   }
+ * });
+ * ```
+ */
+export declare function registerInlineTokenRenderer(params: RegisterInlineTokenRendererParams): void;

package/dist/lib/cjs/link-and-tag-input-suggest.cjs

@@ -0,0 +1,325 @@
+/*
+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) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var link_and_tag_input_suggest_exports = {};
+__export(link_and_tag_input_suggest_exports, {
+  LinkAndTagCompletionKind: () => LinkAndTagCompletionKind,
+  LinkAndTagInputSuggest: () => LinkAndTagInputSuggest,
+  getLinkAndTagCompletionTrigger: () => getLinkAndTagCompletionTrigger,
+  getVaultTagSuggestions: () => getVaultTagSuggestions
+});
+module.exports = __toCommonJS(link_and_tag_input_suggest_exports);
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_obsidian = require('obsidian');
+var LinkAndTagCompletionKind = /* @__PURE__ */ ((LinkAndTagCompletionKind2) => {
+  LinkAndTagCompletionKind2["Link"] = "link";
+  LinkAndTagCompletionKind2["Tag"] = "tag";
+  return LinkAndTagCompletionKind2;
+})(LinkAndTagCompletionKind || {});
+const LINK_OPEN = "[[";
+const LINK_CLOSE = "]]";
+const TAG_PREFIX = "#";
+const TAG_BEFORE_CARET_REG_EXP = /(?:^|\s)#[\p{L}\p{N}_/-]*$/u;
+class LinkAndTagInputSuggest extends import_obsidian.AbstractInputSuggest {
+  /**
+   * The element the suggest completes in.
+   */
+  inputEl;
+  /**
+   * Whether `[[` completes links.
+   */
+  shouldSuggestLinks;
+  /**
+   * Whether `#` completes tags.
+   */
+  shouldSuggestTags;
+  /**
+   * The path that inserted links are relative to.
+   */
+  sourcePath;
+  /**
+   * Creates the suggest and attaches it to the element.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super(params.app, (0, import_object_utils.castTo)(params.inputEl));
+    this.inputEl = params.inputEl;
+    this.shouldSuggestLinks = params.shouldSuggestLinks ?? true;
+    this.shouldSuggestTags = params.shouldSuggestTags ?? true;
+    this.sourcePath = params.sourcePath ?? "";
+  }
+  /**
+   * Gets the value of the element.
+   *
+   * @returns The value.
+   */
+  getValue() {
+    return this.inputEl.value;
+  }
+  /**
+   * Renders a suggestion.
+   *
+   * @param suggestion - The suggestion.
+   * @param el - The element to render into.
+   */
+  renderSuggestion(suggestion, el) {
+    if (suggestion.kind === "link" /* Link */) {
+      el.createDiv({ cls: "suggestion-title", text: suggestion.linktext });
+      if (suggestion.linktext !== suggestion.file.path) {
+        el.createDiv({ cls: "suggestion-note", text: suggestion.file.path });
+      }
+      return;
+    }
+    el.addClass("mod-complex");
+    el.createDiv({ cls: "suggestion-content", text: `${TAG_PREFIX}${suggestion.tag}` });
+    el.createDiv({ cls: "suggestion-aux", text: String(suggestion.count) });
+  }
+  /**
+   * Inserts the suggestion in place of the trigger, moves the caret after it and dispatches an `input` event, so a
+   * component listening on the element sees the change.
+   *
+   * @param suggestion - The suggestion.
+   * @param $event - The event that selected it.
+   */
+  selectSuggestion(suggestion, $event) {
+    const trigger = this.getTrigger();
+    if (trigger) {
+      const value = this.getValue();
+      let after = value.slice(trigger.end);
+      let insertion;
+      if (suggestion.kind === "link" /* Link */) {
+        insertion = `${LINK_OPEN}${suggestion.linktext}${LINK_CLOSE}`;
+        if (after.startsWith(LINK_CLOSE)) {
+          after = after.slice(LINK_CLOSE.length);
+        }
+      } else {
+        insertion = `${TAG_PREFIX}${suggestion.tag} `;
+      }
+      this.setValue(value.slice(0, trigger.start) + insertion + after);
+      const caret = trigger.start + insertion.length;
+      this.inputEl.setSelectionRange(caret, caret);
+      this.inputEl.dispatchEvent(new Event("input", { bubbles: true }));
+    }
+    super.selectSuggestion(suggestion, $event);
+    this.close();
+  }
+  /**
+   * Sets the value of the element.
+   *
+   * @param value - The value.
+   */
+  setValue(value) {
+    this.inputEl.value = value;
+  }
+  /**
+   * Gets the link suggestions for a query.
+   *
+   * @param query - The text typed after `[[`.
+   * @returns The suggestions, best match first.
+   */
+  getLinkSuggestions(query) {
+    const fuzzySearch = (0, import_obsidian.prepareFuzzySearch)(query);
+    const results = [];
+    for (const file of this.app.vault.getFiles()) {
+      const linktext = this.app.metadataCache.fileToLinktext(file, this.sourcePath, true);
+      const match = fuzzySearch(linktext) ?? fuzzySearch(file.path);
+      if (match) {
+        results.push({ match, suggestion: { file, kind: "link" /* Link */, linktext } });
+      }
+    }
+    (0, import_obsidian.sortSearchResults)(results);
+    return results.map((result) => result.suggestion);
+  }
+  /**
+   * Gets the suggestions for the trigger before the caret. The query Obsidian passes is the whole value, so it is
+   * ignored.
+   *
+   * @returns The suggestions.
+   */
+  getSuggestions() {
+    const trigger = this.getTrigger();
+    if (trigger?.kind === "link" /* Link */) {
+      return this.getLinkSuggestions(trigger.query);
+    }
+    return trigger?.kind === "tag" /* Tag */ ? this.getTagSuggestions(trigger.query) : [];
+  }
+  /**
+   * Gets the tag suggestions for a query, from the tags of every note.
+   *
+   * @param query - The text typed after `#`.
+   * @returns The suggestions, best match first, then the most used.
+   */
+  getTagSuggestions(query) {
+    return getVaultTagSuggestions({ app: this.app, query });
+  }
+  /**
+   * Gets the enabled trigger before the caret.
+   *
+   * @returns The trigger, or `null`.
+   */
+  getTrigger() {
+    const value = this.getValue();
+    const trigger = getLinkAndTagCompletionTrigger(value, this.inputEl.selectionStart ?? value.length);
+    if (trigger?.kind === "link" /* Link */ && !this.shouldSuggestLinks) {
+      return null;
+    }
+    return trigger?.kind === "tag" /* Tag */ && !this.shouldSuggestTags ? null : trigger;
+  }
+}
+function getLinkAndTagCompletionTrigger(text, caret) {
+  const beforeCaret = text.slice(0, caret);
+  const linkStart = beforeCaret.lastIndexOf(LINK_OPEN);
+  if (linkStart !== -1) {
+    const query = beforeCaret.slice(linkStart + LINK_OPEN.length);
+    if (!query.includes(LINK_CLOSE) && !query.includes("\n") && !query.includes("|")) {
+      return { end: caret, kind: "link" /* Link */, query, start: linkStart };
+    }
+  }
+  if (TAG_BEFORE_CARET_REG_EXP.test(beforeCaret)) {
+    const start = beforeCaret.lastIndexOf(TAG_PREFIX);
+    return { end: caret, kind: "tag" /* Tag */, query: beforeCaret.slice(start + TAG_PREFIX.length), start };
+  }
+  return null;
+}
+function getVaultTagSuggestions(params) {
+  const { app, query } = params;
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of app.vault.getMarkdownFiles()) {
+    const cache = app.metadataCache.getFileCache(file);
+    for (const tag of (cache ? (0, import_obsidian.getAllTags)(cache) : null) ?? []) {
+      const name = tag.slice(TAG_PREFIX.length);
+      counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+  }
+  const fuzzySearch = (0, import_obsidian.prepareFuzzySearch)(query);
+  const results = [];
+  const sortedCounts = [...counts].sort(([tag1, count1], [tag2, count2]) => count2 - count1 || tag1.localeCompare(tag2));
+  for (const [tag, count] of sortedCounts) {
+    const match = fuzzySearch(tag);
+    if (match) {
+      results.push({ match, suggestion: { count, kind: "tag" /* Tag */, tag } });
+    }
+  }
+  (0, import_obsidian.sortSearchResults)(results);
+  return results.map((result) => result.suggestion);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LinkAndTagCompletionKind,
+  LinkAndTagInputSuggest,
+  getLinkAndTagCompletionTrigger,
+  getVaultTagSuggestions
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/link-and-tag-input-suggest.ts"],"sourcesContent":["/**\n * @file\n *\n * Completes `[[` links and `#` tags at the caret of any `<input>` or `<textarea>`, the way the editor does.\n */\n\nimport type {\n  App,\n  SearchResult,\n  TFile\n} from 'obsidian';\n\nimport { castTo } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  AbstractInputSuggest,\n  getAllTags,\n  prepareFuzzySearch,\n  sortSearchResults\n} from 'obsidian';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `TagListComponent` to use it in the tsdocs.\nimport type { TagListComponent } from './setting-components/tag-list-component.ts';\n\n/**\n * What a completion trigger completes.\n */\nexport enum LinkAndTagCompletionKind {\n  /**\n   * A `[[` wikilink to a vault file.\n   */\n  Link = 'link',\n\n  /**\n   * A `#` tag.\n   */\n  Tag = 'tag'\n}\n\n/**\n * A completion trigger found before the caret.\n */\nexport interface LinkAndTagCompletionTrigger {\n  /**\n   * The offset of the caret, where the query ends.\n   */\n  readonly end: number;\n\n  /**\n   * What the trigger completes.\n   */\n  readonly kind: LinkAndTagCompletionKind;\n\n  /**\n   * The text typed after the trigger characters.\n   */\n  readonly query: string;\n\n  /**\n   * The offset of the trigger characters: the first `[` of `[[`, or the `#`.\n   */\n  readonly start: number;\n}\n\n/**\n * Parameters of {@link LinkAndTagInputSuggest}.\n */\nexport interface LinkAndTagInputSuggestConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The element to complete in.\n   */\n  readonly inputEl: HTMLInputElement | HTMLTextAreaElement;\n\n  /**\n   * Whether `[[` completes links. Defaults to `true`.\n   */\n  readonly shouldSuggestLinks?: boolean;\n\n  /**\n   * Whether `#` completes tags. Defaults to `true`.\n   */\n  readonly shouldSuggestTags?: boolean;\n\n  /**\n   * The path that inserted links are relative to. Defaults to the vault root.\n   */\n  readonly sourcePath?: string;\n}\n\n/**\n * A suggestion of {@link LinkAndTagInputSuggest}.\n */\nexport type LinkAndTagSuggestion = LinkSuggestion | TagSuggestion;\n\n/**\n * A suggested link.\n */\nexport interface LinkSuggestion {\n  /**\n   * The file the link points to.\n   */\n  readonly file: TFile;\n\n  /**\n   * The kind of the suggestion.\n   */\n  readonly kind: LinkAndTagCompletionKind.Link;\n\n  /**\n   * The link text inserted between `[[` and `]]`.\n   */\n  readonly linktext: string;\n}\n\n/**\n * A suggested tag.\n */\nexport interface TagSuggestion {\n  /**\n   * How many tag occurrences the vault holds.\n   */\n  readonly count: number;\n\n  /**\n   * The kind of the suggestion.\n   */\n  readonly kind: LinkAndTagCompletionKind.Tag;\n\n  /**\n   * The tag, without its `#`.\n   */\n  readonly tag: string;\n}\n\ninterface SuggestionSearchResult<T> {\n  readonly match: SearchResult;\n  readonly suggestion: T;\n}\n\nconst LINK_OPEN = '[[';\nconst LINK_CLOSE = ']]';\nconst TAG_PREFIX = '#';\nconst TAG_BEFORE_CARET_REG_EXP = /(?:^|\\s)#[\\p{L}\\p{N}_/-]*$/u;\n\n/**\n * Parameters for {@link getVaultTagSuggestions}.\n */\nexport interface GetVaultTagSuggestionsParams {\n  /**\n   * The Obsidian app.\n   */\n  readonly app: App;\n\n  /**\n   * The text typed, without the `#`.\n   */\n  readonly query: string;\n}\n\n/**\n * Completes `[[` links and `#` tags inside any `<input>` or `<textarea>`.\n *\n * Obsidian's {@link AbstractInputSuggest} treats the whole value as the query and replaces it on selection. This one\n * reads the trigger before the caret and replaces only that, so it works inside free text such as a template or a\n * description setting, and it accepts a `<textarea>` too.\n *\n * ```ts\n * new Setting(containerEl).addTextArea((textArea) => {\n *   new LinkAndTagInputSuggest({ app: this.app, inputEl: textArea.inputEl });\n * });\n * ```\n */\nexport class LinkAndTagInputSuggest extends AbstractInputSuggest<LinkAndTagSuggestion> {\n  /**\n   * The element the suggest completes in.\n   */\n  protected readonly inputEl: HTMLInputElement | HTMLTextAreaElement;\n\n  /**\n   * Whether `[[` completes links.\n   */\n  protected readonly shouldSuggestLinks: boolean;\n\n  /**\n   * Whether `#` completes tags.\n   */\n  protected readonly shouldSuggestTags: boolean;\n\n  /**\n   * The path that inserted links are relative to.\n   */\n  protected readonly sourcePath: string;\n\n  /**\n   * Creates the suggest and attaches it to the element.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: LinkAndTagInputSuggestConstructorParams) {\n    // Obsidian's suggest reads the value only through `getValue` and `setValue`, both overridden here, so a textarea works too.\n    super(params.app, castTo<HTMLInputElement>(params.inputEl));\n    this.inputEl = params.inputEl;\n    this.shouldSuggestLinks = params.shouldSuggestLinks ?? true;\n    this.shouldSuggestTags = params.shouldSuggestTags ?? true;\n    this.sourcePath = params.sourcePath ?? '';\n  }\n\n  /**\n   * Gets the value of the element.\n   *\n   * @returns The value.\n   */\n  public override getValue(): string {\n    return this.inputEl.value;\n  }\n\n  /**\n   * Renders a suggestion.\n   *\n   * @param suggestion - The suggestion.\n   * @param el - The element to render into.\n   */\n  public renderSuggestion(suggestion: LinkAndTagSuggestion, el: HTMLElement): void {\n    if (suggestion.kind === LinkAndTagCompletionKind.Link) {\n      el.createDiv({ cls: 'suggestion-title', text: suggestion.linktext });\n      if (suggestion.linktext !== suggestion.file.path) {\n        el.createDiv({ cls: 'suggestion-note', text: suggestion.file.path });\n      }\n      return;\n    }\n\n    el.addClass('mod-complex');\n    el.createDiv({ cls: 'suggestion-content', text: `${TAG_PREFIX}${suggestion.tag}` });\n    el.createDiv({ cls: 'suggestion-aux', text: String(suggestion.count) });\n  }\n\n  /**\n   * Inserts the suggestion in place of the trigger, moves the caret after it and dispatches an `input` event, so a\n   * component listening on the element sees the change.\n   *\n   * @param suggestion - The suggestion.\n   * @param $event - The event that selected it.\n   */\n  public override selectSuggestion(suggestion: LinkAndTagSuggestion, $event: KeyboardEvent | MouseEvent): void {\n    const trigger = this.getTrigger();\n    if (trigger) {\n      const value = this.getValue();\n      let after = value.slice(trigger.end);\n      let insertion: string;\n      if (suggestion.kind === LinkAndTagCompletionKind.Link) {\n        insertion = `${LINK_OPEN}${suggestion.linktext}${LINK_CLOSE}`;\n        if (after.startsWith(LINK_CLOSE)) {\n          after = after.slice(LINK_CLOSE.length);\n        }\n      } else {\n        insertion = `${TAG_PREFIX}${suggestion.tag} `;\n      }\n\n      this.setValue(value.slice(0, trigger.start) + insertion + after);\n      const caret = trigger.start + insertion.length;\n      this.inputEl.setSelectionRange(caret, caret);\n      this.inputEl.dispatchEvent(new Event('input', { bubbles: true }));\n    }\n\n    super.selectSuggestion(suggestion, $event);\n    this.close();\n  }\n\n  /**\n   * Sets the value of the element.\n   *\n   * @param value - The value.\n   */\n  public override setValue(value: string): void {\n    this.inputEl.value = value;\n  }\n\n  /**\n   * Gets the link suggestions for a query.\n   *\n   * @param query - The text typed after `[[`.\n   * @returns The suggestions, best match first.\n   */\n  protected getLinkSuggestions(query: string): LinkSuggestion[] {\n    const fuzzySearch = prepareFuzzySearch(query);\n    const results: SuggestionSearchResult<LinkSuggestion>[] = [];\n    for (const file of this.app.vault.getFiles()) {\n      const linktext = this.app.metadataCache.fileToLinktext(file, this.sourcePath, true);\n      const match = fuzzySearch(linktext) ?? fuzzySearch(file.path);\n      if (match) {\n        results.push({ match, suggestion: { file, kind: LinkAndTagCompletionKind.Link, linktext } });\n      }\n    }\n    sortSearchResults(results);\n    return results.map((result) => result.suggestion);\n  }\n\n  /**\n   * Gets the suggestions for the trigger before the caret. The query Obsidian passes is the whole value, so it is\n   * ignored.\n   *\n   * @returns The suggestions.\n   */\n  protected override getSuggestions(): LinkAndTagSuggestion[] {\n    const trigger = this.getTrigger();\n    if (trigger?.kind === LinkAndTagCompletionKind.Link) {\n      return this.getLinkSuggestions(trigger.query);\n    }\n    return trigger?.kind === LinkAndTagCompletionKind.Tag ? this.getTagSuggestions(trigger.query) : [];\n  }\n\n  /**\n   * Gets the tag suggestions for a query, from the tags of every note.\n   *\n   * @param query - The text typed after `#`.\n   * @returns The suggestions, best match first, then the most used.\n   */\n  protected getTagSuggestions(query: string): TagSuggestion[] {\n    return getVaultTagSuggestions({ app: this.app, query });\n  }\n\n  /**\n   * Gets the enabled trigger before the caret.\n   *\n   * @returns The trigger, or `null`.\n   */\n  protected getTrigger(): LinkAndTagCompletionTrigger | null {\n    const value = this.getValue();\n    const trigger = getLinkAndTagCompletionTrigger(value, this.inputEl.selectionStart ?? value.length);\n    if (trigger?.kind === LinkAndTagCompletionKind.Link && !this.shouldSuggestLinks) {\n      return null;\n    }\n    return trigger?.kind === LinkAndTagCompletionKind.Tag && !this.shouldSuggestTags ? null : trigger;\n  }\n}\n\n/**\n * Finds the `[[` link or `#` tag being typed before the caret.\n *\n * A link trigger is an unclosed `[[` on the caret's line with no `|` after it, so an alias being typed is left alone. A\n * tag trigger is a `#` at the start of the text or after whitespace, followed only by tag characters.\n *\n * @param text - The text of the element.\n * @param caret - The offset of the caret.\n * @returns The trigger, or `null` when the caret is not in one.\n */\nexport function getLinkAndTagCompletionTrigger(text: string, caret: number): LinkAndTagCompletionTrigger | null {\n  const beforeCaret = text.slice(0, caret);\n  const linkStart = beforeCaret.lastIndexOf(LINK_OPEN);\n  if (linkStart !== -1) {\n    const query = beforeCaret.slice(linkStart + LINK_OPEN.length);\n    if (!query.includes(LINK_CLOSE) && !query.includes('\\n') && !query.includes('|')) {\n      return { end: caret, kind: LinkAndTagCompletionKind.Link, query, start: linkStart };\n    }\n  }\n\n  if (TAG_BEFORE_CARET_REG_EXP.test(beforeCaret)) {\n    // The query holds no #, so the last one is the trigger.\n    const start = beforeCaret.lastIndexOf(TAG_PREFIX);\n    return { end: caret, kind: LinkAndTagCompletionKind.Tag, query: beforeCaret.slice(start + TAG_PREFIX.length), start };\n  }\n\n  return null;\n}\n\n/**\n * Gets the tags of every note matching a query, as {@link LinkAndTagInputSuggest} and {@link TagListComponent}\n * suggest them.\n *\n * @param params - The parameters.\n * @returns The suggestions, best match first, then the most used.\n */\nexport function getVaultTagSuggestions(params: GetVaultTagSuggestionsParams): TagSuggestion[] {\n  const { app, query } = params;\n  const counts = new Map<string, number>();\n  for (const file of app.vault.getMarkdownFiles()) {\n    const cache = app.metadataCache.getFileCache(file);\n    for (const tag of (cache ? getAllTags(cache) : null) ?? []) {\n      const name = tag.slice(TAG_PREFIX.length);\n      counts.set(name, (counts.get(name) ?? 0) + 1);\n    }\n  }\n\n  const fuzzySearch = prepareFuzzySearch(query);\n  const results: SuggestionSearchResult<TagSuggestion>[] = [];\n  const sortedCounts = [...counts].sort(([tag1, count1], [tag2, count2]) => count2 - count1 || tag1.localeCompare(tag2));\n  for (const [tag, count] of sortedCounts) {\n    const match = fuzzySearch(tag);\n    if (match) {\n      results.push({ match, suggestion: { count, kind: LinkAndTagCompletionKind.Tag, tag } });\n    }\n  }\n  sortSearchResults(results);\n  return results.map((result) => result.suggestion);\n}\n"],"mappings":"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","names":["LinkAndTagCompletionKind"]}

package/dist/lib/cjs/link-and-tag-input-suggest.d.cts

@@ -0,0 +1,229 @@
+/// <reference path="./library-references.d.cts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Completes `[[` links and `#` tags at the caret of any `<input>` or `<textarea>`, the way the editor does.
+ */
+import type { App, TFile } from 'obsidian' with { 'resolution-mode': 'import' };
+import { AbstractInputSuggest } from 'obsidian';
+/**
+ * What a completion trigger completes.
+ */
+export declare enum LinkAndTagCompletionKind {
+    /**
+     * A `[[` wikilink to a vault file.
+     */
+    Link = "link",
+    /**
+     * A `#` tag.
+     */
+    Tag = "tag"
+}
+/**
+ * A completion trigger found before the caret.
+ */
+export interface LinkAndTagCompletionTrigger {
+    /**
+     * The offset of the caret, where the query ends.
+     */
+    readonly end: number;
+    /**
+     * What the trigger completes.
+     */
+    readonly kind: LinkAndTagCompletionKind;
+    /**
+     * The text typed after the trigger characters.
+     */
+    readonly query: string;
+    /**
+     * The offset of the trigger characters: the first `[` of `[[`, or the `#`.
+     */
+    readonly start: number;
+}
+/**
+ * Parameters of {@link LinkAndTagInputSuggest}.
+ */
+export interface LinkAndTagInputSuggestConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The element to complete in.
+     */
+    readonly inputEl: HTMLInputElement | HTMLTextAreaElement;
+    /**
+     * Whether `[[` completes links. Defaults to `true`.
+     */
+    readonly shouldSuggestLinks?: boolean;
+    /**
+     * Whether `#` completes tags. Defaults to `true`.
+     */
+    readonly shouldSuggestTags?: boolean;
+    /**
+     * The path that inserted links are relative to. Defaults to the vault root.
+     */
+    readonly sourcePath?: string;
+}
+/**
+ * A suggestion of {@link LinkAndTagInputSuggest}.
+ */
+export type LinkAndTagSuggestion = LinkSuggestion | TagSuggestion;
+/**
+ * A suggested link.
+ */
+export interface LinkSuggestion {
+    /**
+     * The file the link points to.
+     */
+    readonly file: TFile;
+    /**
+     * The kind of the suggestion.
+     */
+    readonly kind: LinkAndTagCompletionKind.Link;
+    /**
+     * The link text inserted between `[[` and `]]`.
+     */
+    readonly linktext: string;
+}
+/**
+ * A suggested tag.
+ */
+export interface TagSuggestion {
+    /**
+     * How many tag occurrences the vault holds.
+     */
+    readonly count: number;
+    /**
+     * The kind of the suggestion.
+     */
+    readonly kind: LinkAndTagCompletionKind.Tag;
+    /**
+     * The tag, without its `#`.
+     */
+    readonly tag: string;
+}
+/**
+ * Parameters for {@link getVaultTagSuggestions}.
+ */
+export interface GetVaultTagSuggestionsParams {
+    /**
+     * The Obsidian app.
+     */
+    readonly app: App;
+    /**
+     * The text typed, without the `#`.
+     */
+    readonly query: string;
+}
+/**
+ * Completes `[[` links and `#` tags inside any `<input>` or `<textarea>`.
+ *
+ * Obsidian's {@link AbstractInputSuggest} treats the whole value as the query and replaces it on selection. This one
+ * reads the trigger before the caret and replaces only that, so it works inside free text such as a template or a
+ * description setting, and it accepts a `<textarea>` too.
+ *
+ * ```ts
+ * new Setting(containerEl).addTextArea((textArea) => {
+ *   new LinkAndTagInputSuggest({ app: this.app, inputEl: textArea.inputEl });
+ * });
+ * ```
+ */
+export declare class LinkAndTagInputSuggest extends AbstractInputSuggest<LinkAndTagSuggestion> {
+    /**
+     * The element the suggest completes in.
+     */
+    protected readonly inputEl: HTMLInputElement | HTMLTextAreaElement;
+    /**
+     * Whether `[[` completes links.
+     */
+    protected readonly shouldSuggestLinks: boolean;
+    /**
+     * Whether `#` completes tags.
+     */
+    protected readonly shouldSuggestTags: boolean;
+    /**
+     * The path that inserted links are relative to.
+     */
+    protected readonly sourcePath: string;
+    /**
+     * Creates the suggest and attaches it to the element.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: LinkAndTagInputSuggestConstructorParams);
+    /**
+     * Gets the value of the element.
+     *
+     * @returns The value.
+     */
+    getValue(): string;
+    /**
+     * Renders a suggestion.
+     *
+     * @param suggestion - The suggestion.
+     * @param el - The element to render into.
+     */
+    renderSuggestion(suggestion: LinkAndTagSuggestion, el: HTMLElement): void;
+    /**
+     * Inserts the suggestion in place of the trigger, moves the caret after it and dispatches an `input` event, so a
+     * component listening on the element sees the change.
+     *
+     * @param suggestion - The suggestion.
+     * @param $event - The event that selected it.
+     */
+    selectSuggestion(suggestion: LinkAndTagSuggestion, $event: KeyboardEvent | MouseEvent): void;
+    /**
+     * Sets the value of the element.
+     *
+     * @param value - The value.
+     */
+    setValue(value: string): void;
+    /**
+     * Gets the link suggestions for a query.
+     *
+     * @param query - The text typed after `[[`.
+     * @returns The suggestions, best match first.
+     */
+    protected getLinkSuggestions(query: string): LinkSuggestion[];
+    /**
+     * Gets the suggestions for the trigger before the caret. The query Obsidian passes is the whole value, so it is
+     * ignored.
+     *
+     * @returns The suggestions.
+     */
+    protected getSuggestions(): LinkAndTagSuggestion[];
+    /**
+     * Gets the tag suggestions for a query, from the tags of every note.
+     *
+     * @param query - The text typed after `#`.
+     * @returns The suggestions, best match first, then the most used.
+     */
+    protected getTagSuggestions(query: string): TagSuggestion[];
+    /**
+     * Gets the enabled trigger before the caret.
+     *
+     * @returns The trigger, or `null`.
+     */
+    protected getTrigger(): LinkAndTagCompletionTrigger | null;
+}
+/**
+ * Finds the `[[` link or `#` tag being typed before the caret.
+ *
+ * A link trigger is an unclosed `[[` on the caret's line with no `|` after it, so an alias being typed is left alone. A
+ * tag trigger is a `#` at the start of the text or after whitespace, followed only by tag characters.
+ *
+ * @param text - The text of the element.
+ * @param caret - The offset of the caret.
+ * @returns The trigger, or `null` when the caret is not in one.
+ */
+export declare function getLinkAndTagCompletionTrigger(text: string, caret: number): LinkAndTagCompletionTrigger | null;
+/**
+ * Gets the tags of every note matching a query, as {@link LinkAndTagInputSuggest} and {@link TagListComponent}
+ * suggest them.
+ *
+ * @param params - The parameters.
+ * @returns The suggestions, best match first, then the most used.
+ */
+export declare function getVaultTagSuggestions(params: GetVaultTagSuggestionsParams): TagSuggestion[];